{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:03.702378Z",
     "start_time": "2025-01-17T12:22:03.695637Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:03.805515Z",
     "start_time": "2025-01-17T12:22:03.757105Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:14.341329Z",
     "start_time": "2025-01-17T12:22:03.807517Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:14.355948Z",
     "start_time": "2025-01-17T12:22:14.342334Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU()) # 这里采用SELU激活函数\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:14.402753Z",
     "start_time": "2025-01-17T12:22:14.357966Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:17.938805Z",
     "start_time": "2025-01-17T12:22:14.404263Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:17.947789Z",
     "start_time": "2025-01-17T12:22:17.940809Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:22:17.954800Z",
     "start_time": "2025-01-17T12:22:17.948793Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:35:41.399302Z",
     "start_time": "2025-01-17T12:22:17.956811Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/selu\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints/selu\"):\n",
    "    #创建多级目录\n",
    "    os.makedirs(\"checkpoints/selu\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/selu\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "4c4e2a2785be4e81a3d7415dbc351f5b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 30 / global_step 112500\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:35:41.732329Z",
     "start_time": "2025-01-17T12:35:41.400306Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9UAAAHACAYAAACszkseAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAshRJREFUeJzs3Qd4U2XbB/B/mjbdBUone+89BQRRGQriVpyAW19x4cRPcb2Ke6O4EPfeMgThRaYie++9uoDulSbfdT8nJyR0pW3arP+P61wZTdKTpy0n93nu574NVqvVCiIiIiIiIiKqsqCqP4WIiIiIiIiIBINqIiIiIiIiompiUE1ERERERERUTQyqiYiIiIiIiKqJQTURERERERFRNTGoJiIiIiIiIqomBtVERERERERE1cSgmoiIiIiIiKiaguEDLBYLjhw5gujoaBgMBk/vDhERBTir1Yrs7Gw0atQIQUE8P+0OPNYTEZGvHu99IqiWg2zTpk09vRtERERODh48iCZNmnh6N/wCj/VEROSrx3ufCKrlrLX+ZmJiYmr0WsXFxZg3bx5GjBiBkJAQBDqOR2kcE2ccD2ccj9ICcUyysrJUAKgfn6jmeKyvXRwTZxwPZxwPZxyP0gJ1TLJcPN77RFCtp4HJQdYdB9qIiAj1OoH0C1EejkdpHBNnHA9nHI/SAnlMmKbsPjzW1y6OiTOOhzOOhzOOR2mBPiaGSo73XAhGREREREREVE0MqomIiIiIiIiqiUE1ERERERERUTX5xJpqIiJfa79gNptRUlKCQFlnFRwcjIKCAr96z0ajUb0vrpsmIiKiijCoJiJyo6KiIhw9ehR5eXkIpJMISUlJqmqzvwWgUpQlOTkZJpPJ07tCREREXopBNRGRm1gsFuzdu1fNcDZq1EgFYv4WZJb3vnNychAVFYWgoCC/OVEgJ0jS0tLUz7Rt27Z+896IiIjIvRhUExG5iQRhEmBKP0OZ4QwU8p7lvYeFhflV4BkeHq7ahuzfv9/+/oiIiIhO5z+ffoiIvIQ/BZaBjj9LIiIiqgw/LRARERERERFVE4NqIiIiIiIiompiUE1ERG7VokULvP766255rUWLFqlibydPnnTL65FrFi9ejDFjxqiCezL+P//8s0s/q169eiE0NBRt2rTBzJkz62RfiYiIPI1BNRERYejQobj33nvd8lr//vsvbr31Vre8FnlGbm4uunfvjmnTprn0eKmQPnr0aJx99tlYt26d+l26+eab8ccff9T6vhIREXkaq38TEZFLLaZKSkoQHFz5YSM+Pr5O9olqz/nnn682V02fPh0tW7bEK6+8om537NgRS5cuxWuvvYaRI0fW4p4SERF5XkAF1YdO5OE/X6zG8RNGjBrl6b0hokAJRvOLSzzyvcNDjC71yZ4wYQL++usvtb3xxhvqvo8//hg33HADZs+ejcceewwbN27EvHnzVLuwSZMm4e+//1azmRI8Pfvss+jXr59T+rfMVOoz37IPH3zwAWbNmqVmLhs3bqyCrwsvvLBa7+uHH37AlClTsGvXLiQnJ+Ouu+7C/fffb//6O++8o4K5gwcPol69ehg8eDC+//579TW5fOqpp9Rzpe1Zz5498csvvyAyMrJa+0KaFStWYNiwYU73STBdUfZDYWGh2nRZWVnqsri4WG01oT+/pq9TU8t3Z+CTFQfw5JiOSK7n2ZZs3jIm3oLj4Yzj4Z3jcfhkPv7v5y24qm8TnNc50aP74i1jUtdcfb8BFVSHhRix4VAW5COmucSCkBBP7xER+TsJqDtN8UwK7JanRyLCVPl/8xJI79ixA126dMHTTz+t7tu8ebO6fOSRR/Dyyy+jVatWaNCggQpUR40apQJpWTv76aef4qKLLsLKlSvRuXPncr+HBLIvvvgiXnrpJbz11lu49tprVf/n2NjYKr2n1atX48orr8STTz6JsWPHYvny5fjPf/6Dhg0bqpMDq1atwt13343PPvsMAwcOxPHjx7FkyRL13KNHj+Lqq69W+3HJJZcgOztbfU1OfFDNHDt2DImJzh/45LYEyvn5+arn9+mmTp2qfi9OJydv3NXnff78+fCk97YGYcvJIJRkpuDSlhZ4A0+PibfheDjjeHjXeHy+Kwj/pgVh5d50HOtWgoTS/5UG3JjUtby8PJceF1BBdWyECcFBBpgtQHpuEZqGhXp6l4iIPE5mc00mkwpkkpKS1H3btm1TlxJkDx8+3P5YCYJlra3umWeewU8//YQ5c+ZUGFRLwCsBrXjuuefw5ptvqkD8vPPOq9K+vvrqqzj33HPx+OOPq9vt2rXDli1bVLAu3+PAgQNq1vmCCy5AdHQ0mjdvrmaj9aDabDbj0ksvVfeLrl27Vun7k/tMnjxZZT3oJACXTIgRI0YgJiamxjML8sFPfndDPHgG/b19K4CT2diaG46R5w2BMajyzJHa4i1j4i04Hs44Ht43HkczC3D/P3JS2IpiiwGzMxriq5v7eez/EW8YE0/Qs6gqE1BBdVCQAQ2jTEjJKkRadiGaNoz29C4RkZ+TFGyZMfbU966pPn36ON3OyclRs8SSyq0HqTITeejQoQpfp1u3bvbrEvRK0JSamlrl/dm6dauaGXc0aNAgVW1c1nzLwV4CZplZl4BdNpmVlhMGcjJAAnIJpCU1WYK3yy+/XM3AU83IyZiUlBSn++S2/JzLmqUWkukg2+nkw5q7PrC587WqIy2nSF2mZhdi3eFsnNGqITzN02PibTgezjge3jMeX6zcBbPFik7JMThwPA9rD2bi4xUHccfQ1vCkQPsdCXHxvQZc9e+E6FD7AY6IqLbJemJJwfbE5sp66sqcvtb4gQceUDPTMtssqdNS6VmC1MrWHJ1+UJJ9s1jcnw4rs9Nr1qzBV199pdZby9prCaalJZfRaFRn2WVWvVOnTioNvX379qpyNdXMgAEDsGDBAqf7ZKzl/kBVYrEiI+fUZ43f1h/x6P4Qke/ILijGl/8cUNfvH9EOU8Z0Utdfm78D2465NnNKdSvggur4KC2oTsvWzh4TERFU+rfM9FZm2bJlKs1aZn8lmJYZyn379qGuSGE02YfT90nSwCVoFlKhXIpmydrpDRs2qP1buHChPZiXmW1Zy7t27Vr1vuUkAaFURoKcMJFNyIkHuS7p9Xrq9rhx4+yPv/3227Fnzx489NBDaumAFIv79ttvcd999yFQSUBtcViuP2fTMVXPhYioMl+vPIjsQjPaJETh7PYJuKJ3EwzrmICiEgvu+2Y9imQtK3mVwAuqbTPVkv5NRESnKnb/888/KgBNT08vdxa5bdu2+PHHH1WAtX79elxzzTW1MuNcHqnyLTOispZbiqt98sknePvtt9UMuvj999/Vem3ZPymEJoXUZP9kRlren8ywSzEzCQ7lfaSlpalAnZzJGMladH09uqx9lusy8y8k9V8PsIW005IlATI7LZkBUt39ww8/DOh2WnpGXMNIE2IjTTieW6SqgRMRVaS4xIIZy7QMqlsGt1TLV+WE8HOXdkWDiBBsPZqFNxfs9PRuUqAH1QnRJnWZ6pCSRUQU6CQolZleSYuWPtOOAdPphcJkDbJU1h4zZowKmnr16lVn+ynfS2ZAv/76a1WtXII8KaYms+eifv36Klg+55xzVLAs/ZMlFVyKqMn63sWLF6vq5TKzLa3CJPirSj/mQDF06FBVFf30bebMmerrcrlo0aJSz5HZf2mTtXv3bvvPJFClZheoy+T6YTivi1YA8PcNTAEnoorJ/xNSpCwuKhQX92xsvz8hOgz/vVgrrvnOol1Ye+CEB/eSArpQmeBMNRFRaRJkSq9hR2UFRTKjradS6+644w6n6pinp4OX1bJK1jhXJbhzdNlll6mtLGeeeWapYE8nQfbcuXNd+r5ENZWaVWj/IDymWyO1PnLupmPqQ7EpOODmNIjIBXK8e++vPer6DYNaIDTYueDo6G7J+GNzI/y6/gju/3Y9Zt09GOGmmhclpZqr0v/q7777rqrgKmf7ZZMCJFLwpTxyJlvSFRy3sLAweFKCfU01g2oiIiKq3fRvKZDar2WsOqmfVWDGkp1pnt41IvJSS3elY9uxbESYjLi2f7MyH/P0RZ3V/yt70nPxwlyt/SX5WFDdpEkTPP/881i9erVabyXpddLaZPPmzeU+R4JvWXulb7LGzRtmqln9m4jI86TAVVRUVJmbfI3I19O/5cOv9JUd3TVZ3f59w1EP7xkReav3F2uz1Ff2aYr6EdqS1dPJ/S9crrWpnLl8H5bvSq/TfSQ3pH/L+jlHzz77rJq9/vvvv9V6tbLI7LRUh/UWelCdnlMEi8WqFv8TEZFnyHpovchYWSdliXw9/Ts+RsvQG9M9WX0Anrf5GAqKSxDmhj7yROQ/Nh/JxJKd6eok3E1ntqzwsVIR/Op+zfDVygN48PsNmHvvYESHBU7vaL9aUy2tV7777jvk5uZW2IdS2nI0b95cVV+VAjNSebW8AFwnRU5k0+lr9aQPamW9UCtTL9QAA6yQSvSpWXmqKmcg08ezpuPqTzgmzjgero+H3CfroeT/u7qsiO1p+ppn/b1XRVxcnNrK4+lxlO8v70t+tnrLLsG/B6pK+rfo2bQBGtcPx+GT+Vi0PRXnddFmromIxIdLtIrfo7omo2lsRKWP/7/RHbF0VxoOHs/HM79vwYuXd6+DvSS3BdUbN25UQXRBQYFKz5P+nlIttizSwmTGjBlqHXZmZiZefvllVTFW0sUllbw8U6dOVT1ETzdv3jxERFT+S1aZyGAjcszAj7P/ROPIGr+cX5A2KOSMY+KM41H5eEh/ZMnMkZOJRUVFCDTZ2dnwN/JzzM/PV1XDzWaz/f68vDyP7hd5v7TTgmrJjJMiQ5Le+dv6owyqicjuyMl8/LZe6w5w6+BWLj0nKjQYr1zRA2PfX4FvVx3CiE5JGNYpsZb3lNwWVEugLP0/JUj+/vvvMX78ePz1119lBtYSfDvOYktALdVX33vvPdVjtDyTJ09WPTEdZ6qbNm2KESNG1DgdUGYXXli/UAXVHXr0w+C25c+QBAIZDwkOhg8fjpAQpo0Ijokzjofr4yEnGw8ePKhOOHq6KGNdkplcCaijo6PVkh9/Ij/T8PBwDBkyxOln6ljtnKisvwl7UG1L/xZSBVyC6gXbUpBbaEZkaMA1YSGiMny8bC/MFisGtGqIrk3qufw8KYJ485kt8cGSvXjkx42Y17wBYgM8C9dTqvy/uclkQps2bdT13r17499//8Ubb7yhAuXKyAfQnj17YteuXRU+LjQ0VG1lPd8dH+pjQqw4AgMy8swMEtw8tv6EY+KM41H5eMiyGAkqg4KC1BYo9BRt/b37E3k/8r5O/3nzb4EqcjKvGEUl2t9FvK3riOjSOAbNG0Zgf0Ye/tyagot6nOpBS0SBKaugGF+tPKiu3zrEtVlqR/ePaI9F29OwMzUHj/+8CW9f09PvTnD7giB3fJhyXP9cEfnAKenjycmeTXmKsZ3AYQVwIiIicjf980WDiBCnntTyQVdmqwWrgBORkB72OYVmtEuMwtD28VV+vhQ9fPXKHggOMmDWxqOqhzV5eVAtadmyrmzfvn0qOJbbixYtwrXXXqu+Pm7cOHWfY1VXWQe9Z88erFmzBtddd51qqXXzzTfDG4Jq9qomIiKi2munVXoZyAXdtYmFv7anITOfBe+IAlmR2aJSv8Utg1tVe4ZZUsYnnqNlEk/5ZTNSsrT/g8hLg+rU1FQVOMu66nPPPVelfv/xxx9qbaE4cOCA6kWtO3HiBG655Ra1jnrUqFFqDdry5cvLLWxWV+qFWJ0OekREVDNSkFKWArlCPjT8/PPPtb5PRB5vp2UrUuaofWI02iREqfTw+VtSPLB3ROQtZFY5JatQFTS8sIeWxVJdd57dBl0b11Mn6x76foO9Mwd54Zrqjz76qMKvy6y1o9dee01t3sae/m076BERERHVVjstR3oK+Gt/7lDVfi/vXX43FCLyXxL0frB4j7p+w6CWCA2uWe/6EGMQXr2yO0a/tRR/7UhT67Sv6d/MTXtLlfGvijJVKFQmuKaaiIiI3E3PhIuPKR1UO6aAL9uVjhO5gdd+j4igAt/tKdmINBndFvy2TYzGgyPaq+v/nbUFBzLY/rGuBGZQbS9UVsDUCCKqXfJ/TFGuZzYX/397//330ahRI3sVb91FF12EG2+8Ebt371bXExMTVbuwvn374s8//3TbEEmNjnPOOUe1rmrYsCFuvfVW1evbMQuqX79+iIyMRP369TFo0CBVn0OsX78eZ599tmrnJS0XpSvFqlWr3LZvRDWbqS67tV7r+Ch0So5RLXTmbj5Wx3tHRN5A2uuJq/o1Q71w93WUuPHMlujXIhZ5RSV44Pv1sFgY69SFgGyQGGP7vS0otiC70IyYMLZGIaJaUpwHPFezdVLV9ugRwBRZ6cOuuOIK3HXXXfjf//6n6mWI48ePY+7cuZg9e7YKcKUuxrPPPqvaHX766acYM2YMtm/fjmbNanZ2PTc3FyNHjsSAAQNUnQ6p3SHFLCdOnIiZM2fCbDbj4osvVvU5vvrqKxQVFWHlypX2Yi5SKFNaNb777rswGo1Yt24d212Rx6VllZ/+7ThbveVolkoBv7ofUzSJAsmmw5lYvjsDxiCDCoLdSV7z5Su647w3FmPl3uOYsWwvbh5c9VZdVDUBOVNtMgLRYdr5BK6rJqJA16BBA5x//vn48ssv7fd9//33iIuLU7PA3bt3x2233YYuXbqgbdu2eOaZZ9C6dWv8+uuvNf7e8j0LCgpUoC6vLzPWb7/9Nj777DOkpKSoApeZmZm44IIL1PeUwpfjx4+3B/NSIHPYsGHo0KGD2jc5QSD7S+Qd1b/LD6r11lp/78lg4VSiAJ2lvqBbMhrXD3f76zdrGIHHRmuFoV/8Yzt2pmS7/XuQs4CcqRbxUaHILjCrA5lU4SQiqhUhEdqMsae+t4tkxldmg9955x01G/3FF1/gqquuQlBQkJqpfvLJJzFr1izV4UFmj/Pz81VAW1Nbt25VQbCkduskvVtS0WUmfMiQIZgwYYKazZZOExJAX3nllUhO1takTpo0Sc1sSxAuX5OgWoJvIq9I/44pO/1bNI2NQPem9bH+4EnM2XgM4we2qMM9JCJPOXQiT/WT1tto1Zar+zXFvC3HsGh7GiZ9ux4//megKmZGtSNgg+qEaBP2pOeyVzUR1S5JU3YhBdvTJJ1bakxI4CxrppcsWWLv3vDAAw9g/vz5ePnll9GmTRu19vnyyy9Xqdh14eOPP8bdd9+t0tG/+eYbPPbYY2p/zjjjDBXsX3PNNWq/58yZgyeeeAJff/01LrnkkjrZN6LT5RSa1VrGymaqxZhuySqo/n3DEQbVdSi7oBj3fr0WWw4Y8c6e5dXuDewusr7+/0Z3RMOoin9f/J2s/ZVU5RW7M/DkhZ3ViSd/NGPpPpRYrBjUpiG6NK5Xa99Hfq9fuKwbRry2GBsPZ2La/3bh3mHtau37BbqADar13pFM/yYiAsLCwnDppZeqGepdu3ahffv26NWrl/rasmXL1GyxHqjKzPW+ffvc8n0lnVvWTsvaan22Wr6fzJDLPuhk3bRskydPVuuvJW1cgmrRrl07td133324+uqrVRDOoJo8JTVLS+WWir6RoRV/zBrdLRn/nbUV/+47gSMn89GoFtJAqbT//r4VC7alSdiBo3mniiJ6yrZj2Vi6Kx2vX9UDA1vHIRBJ5uj9367Hkp3p6vbJ/GJ8e9sAtT7Yn2TmFePrf7Usr1uH1H5WVWJMGJ6+qDPu+Xod3l64C+d2SETXJrUXyAeygA2q9bPHXMdERHQqBVzWLm/evBnXXXed/X5Zq/zjjz+q2Ww58/3444+XqhRek+8ps8uyTlpmndPS0lTRtOuvv15VG9+7d6+qTn7hhReqCuWSEr5z506MGzdOpaA/+OCData8ZcuWOHTokCp2dtlll7ll34hqK/Vbl1wvXFXpXbnvOGZvPMpiQnVg4bYUfLPqoEoiuqpVCUYO7odgo+c+DucVmdWa112pObj2w39w59A2uHdYWwQHUJru4h2SnrwO6TlFCAsJgtFgwOr9J/DBkj24/Sz/Ws7zxcr9KpOlQ1I0hrStmxMoF3ZvhHmbU1TKuYzzb3edibCQmvXEptICNqi2z1Qz/ZuISJEiYbGxsSpwlZRq3auvvqpaaw0cOFAVL3v44YdVATF3iIiIwB9//IF77rlHpZ3LbQmK5XvqX9+2bRs++eQTZGRkqLXUd955pyqcJmu75T4JsKWomeybzLY/9dRTbtk3ourQP1fonzMqI1XAJaiWKuAMqmuX9AR/+IeN6vqEAc3Rw7obg1o39HjHgDPbxuGpX7eoYP/t/+3Cij0ZeOOqHmjSwD/Tn3VFZgtembcd79mKdkmg+fY1PbFm/0k89MMGvDpvB4a2j0eHpBj4g0JzCT5ets++lrqulh3I93nm4i74Z+9x7EzNUWP+f7YiZuQ+gRtU29atMP2biEgjKddHjpQuqtaiRQssXLjQ6T4JbB1t2LBB9Yl2hazddtS1a9dSr6+T2eqffvqpzK+ZTCbVZovIG9O/K1tPrTu/SzKe/HUz1h/KxIGMPFW1l2rH479sUrV0pEDtpGFtsHD+bniDCFMwXri8mwquH/1xo5qlHfXGErx4eTec10Uryuhv5Hf9rq/XqpoC4vozmqt15TKDKn3c/9h8DAu2pWLSN+vx852DYAr2/Zn7X9YdUb9/STFhGNO9blttxkaa8MJlXXHTJ6vw4dK9GN4pCf1axtbpPvg73/8NrSamfxMREZG76QVQE6IrT//WZ7QHtG6orv+2wUOdAgKAZAL8vuGoWqP76pXdvTL9VQKtWXcPVlXhswrMuP3zNfi/nzaioFgrfOcvfl1/BKPfXKIC6piwYEy/rreaSdV/JjKzOvWyrmgQEaJ6ub+1cCf8oQjbB7YZ+RsGtfDISYJzOybiyj5NIOe1H/huPXILzXW+D/4sYINqpn8TEbmfFDqLiooqc+vcubOnd4+oDtdUu17J+QJbz2oJ+qh2sgdkllrceXYbdGtSH95KMhW+v30AbjtLWwrwxT8HcNHby/yiz7CsH3/o+/W4+6u1yC40o0/zBphz7xCc1yWp1GPlpNR/L+6qrr+zaDfW2Wa0fdWiHakq9ToqNBhX92/msf14/IJOqi/2geN5eHb2Vo/thz8KCuSWWkJ6VfvbGUAiIk+RgmLr1q0rc5s9e7and4+o1ukZcK6mf4vzOichOMiArUezVMEqch9ZbvLwDxtwMq8YnRvF4K5z2sDbSS/hyed3xKc39kNclAnbU7Ix5u2l+HrlgVLLZ3yF/G6PeWspvl11SBWJu/ucNvj61jNUgFdRdXwpsiXtp6TAli9/Xn/fNkstvaNjwjy3hj86LAQvXdFNXf/ynwNYtD3VY/vibwI2qJYzRVJhUHBdNRGRe0RHR6te1mVtzZs39/TuEdU6/TOFq+nfokGkSa2nFdKzmtznm38P4n/b02AyBuHVK3uogNVXDGkXj9n3DMbgtnEoKLbgkR83YuJXa5FVUAxfIScBPluxDxdNW4bdablIjAnFFzf3x6QR7V2qcC7toOQE1Z60XLwwdxt80YZDJ/H3nuPqxNkNg1p6endU27YJA1uo63LCSdp8Uc35zv8sbibrNfQDHtdVE5E7+epMApXGnyXVRfq3GGNLAZe1v/y9c4+Dx/PwzO9b1PX7R7RD+6Ro+Br5rPrJDf3wyPkdVFA2a8NRVcRszYET8HYn84pw++er8fgvm1Wl73M6JGD23YOr1Iu7foRJFXETUjl7+W6tj7UvzlLLrLu39KJ/+LwOaBUXiZSsQkz5VVsaQTUTsEG1c7EyzlQTUc3pbVny8vI8vSvkJvrP0tMtd8g3SHpqZn5xldO/xfDOiWo2VWbzth3z/fWz3lAYShVjKipB3xYNfLpdWVCQQfVr/u72AWjSIByHTuTjyukr8O6i3ep9eqN/9x1Xwf8fm1MQYjSotbwfje+DhrbuO1VxdvsEXN1PW4f84HcbkO1DM/VyYkd60Atv+h0MNxnxypXdEWTQqpLr+0jVF7AttRzPIuvtL4iIasJoNKJ+/fpITU2191iuqz6UnmSxWFBUVISCggLVlssfyEyhBNTys5SfqfxsiVyt/C2VfeuFV+1EjKyzlJ6887akqBTwjsn+0ZvXUz5evk/15Y0wGfHyFd1V1W9f17NZA5UOLm23pKidpEPLzK0ER1VZblCbZP3ztP/twut/7oDE+y3jIvHW1T3RpXG9Gr2utNtauisNB4/n47+/b7XPXnu7j5buVeMgKfydGsV43e/Tf4a2Ub3Rpcp8nxYNvOb3yBcFdlBtT//mTDURuUdSklbFVA+sA4EEoPn5+QgPD/e7kwgSUOs/U6LK6J8n4qNCq/W3cEH3Riqo/m39UTwwor3f/T3VFSn29qJt/e2jozqiecNI+As5+SJBqgRpT/y6GUt2pqsZYVkvLmuwPelYZgHu/WatWj8sLu3ZGE9f3EXVMaopeY2XL++Oqz74G9+sOoiRXRJxTodEeHv6u6zpF7cO8Z5Zakd3n9sWC7elqtZlj/64CR+M683/d6opoINqttUiIneTg1FycjISEhJQXOw7KWo1Ie9z8eLFGDJkiF+lSct74Qw1VUWaXvm7iuupdcM6JiA8xKja3Ww8nOnVrZ+8lbnEgvu/XYdCs0UFmdd6sH1RbR5nxvZthl7NGuCur9aq5QLjZqzEbUNa4f4R7T3SA3nB1hSVbn8ir1hlBzxzURdc1ruJW79H/1YNcdOglvhw6V48/MNGzLu3gSry560+/3s/8otL0Ck5Bme2cX0deV2S35VXx3bHhW8tw59bU/D96kO4ok9TT++WTwrooJprqomotkgwFigBmbxPs9mMsLAwvwqqiapdpKyK66l1EaZgnNMxQRWjkoJlDKqrTnoarz+UiZiwYLx4WTe/nnVrmxiNn+8chGdnbcVnf+/He4v34O+9x/HWVT1Vv+u6UGguwfNztqkiYkLalslMeqv4qFr5fg+MbI9FO9JUNsJjv2zCtGt6wVvrK8xcvt8+S+3Nv4cdkmJw3/B2ajnB079twcA2cRW2OqOy+cfit2pKiLGlf3NNNREREXmgndbpxnRLVpcSWHtrESpvtelwJt5csFNdf/qiLkiq5//rQ8NCjHjm4i6Yfl1vdSJh/cGTGP3mEvy6vvZbs+1Jy8Gl7yy3B9Q3DmqJH/8zsNYCav39vnqltkZe/kbq4n1Wx89rDyM9pxCN6oWpftveTgL/3s0bILvQjAe/W8//e6ohsINq25lkvbAIERERUXXpLTqrO1MthrZPUOtHj2QWYO1B72+b5E0zg5O+XQezxYrzuyThoh5ai7JAcV6XJFXErI8tMLr7q7V46Pv1yCsy18r3+2H1IVzw1lJsPpKFBhEhqrL3lDGdEBpc+xlaksEx8ew26vrjP29CipdNjklA+v4SrY3WjWe29Ine6HKS4pUruqvlJ8t3Z+DTFdqJEnKd9/+Ua5F+0MvILUJxicXTu0NEREQB2KP69Jm44Z20AkxSsIxc89r8HdiRkoO4KBP+e3EXr063rS1NGkTg61vPwF3ntIG8/W9XHcKYt5Zi69Est32PnEIz7vtmHe7/TgL2EpzRKhZz7hmCczvWbdGwiee0QdfG9VQLu4d/2OBVvd2l8NeetFxEhwZjbF/fWZ/cIi4Sj47qoK4/P3ebykQg1wV0UN0gwoRgW4sFSdEgIiIi8mT6txjT3ZYCvvGoalFElfdE1mcGn7uka7V6IfuLYGOQKlb2xc39kRgTqvqeXzRtGT5bsa/GgefGQ5m44M0l+GntYdXf+P7h7fDFzWd4JM1eZn8lDVwKbS3anoavbVW2vcH7i7XfxWvOaIboMN+qM3LdGc1VZfmCYgsmfbteFf4j1wR0UB0UZDhVAdx2ICQiIiKqUUutGqR/izPbxKs+17I87Z+9GW7aO/+UW2jG/d+uh8SLl/VqghGd2QJPDGwdh9l3D8Y5HRJQZLbg8V824/bPV6s2T1UlwfiHS/bg0neXYV9Gnlon/M1tA3DXuW092v9bCrU9OKK9uv7f37fg4PE8eNraAyewct9xhBgNuGFgS/gayfB48fJuiA4LxrqDJ1XxO3JNQAfVghXAiYiIqKZkRicjt+bp30Jm386zBYe/b2AKeEWmztmqWpBJoPfEhZ08vTteRWbsZa3z4xd0UkHeH5tTVE9rmdl3VUZOIW6c+S/+O2srikusGNEpUa3d7tsiFt5A1iz3axGL3KIS1UrNkpMOpGwG9i4BDq4Ejm0EMnYDmYeBvONAcb6cJai1/fnAljFxYffGPlsoL7leOJ66sLO6/vqfO7DliPuWD1SbxaL97PJPAjmpwMmDQPou7Wd9eA1w4G9gz1/AzvnA1t+Bjd8DR9ejLgV0Sy0Rr1K0Mu3FRYiIiIiqSuqzyGd1mbhrGFnz9OMLuifjm1UHMWfjUfUB1xeKHdW1xTvS8PnfB9T1l67ojhgfS7V1C0sJUJilBRsFJ09dmouAmEYw1G+KmwY0UYHnXV+tUTPNY99bgXuHtcOdZ7epcKZ5+e503Pv1OjXxJCd6Hh/dUaUH1/l6dfnDkoA45xiQfRTITrFdHoMx5xg+wxGkhx5A3NETCHrZlcJsBiAkHAgOA0IigBC5DAdMUUBEQyAiFkFhDdA6JRWGDVlAdAIQHqvuV18PqydTus4vaS7CoUP7cGTzMpwbdBIPxh0E/voDyEmxbam2yzQgNApo0AKo31y7bND81O2YRkCQ59txXtKzMeZuOoZ5W1JUAcBfJg6qm5nYnFQtUE7dom0pW4C07UBxbtVfa+BdQHJ31JXACqoLshC0/hu0TJMzF6OcziYz/ZuIiIiqS/8cERcV6paU2AGtGqJhpEkF61KN96x28W7YS/+RmVeMh77foK6PH9Acg9rEwScC4PwTQFEOUFwAmPNtl7ZNZuLsl4Wnvl6cBxRkasGyXNoD6EwtoEYlM6+GIHSNTsaCBk2wzhiDFccjcHhhHF7Y3BK3jBmK+CZtnEICybp4Y8FOvP2/XSqebR0fibev6YWOyTE1e/+F2cD2uVpAXJSrBUpFedr7k9vqvjyHS/ma7X5L+cGyfJJv7PAnVxIWC2NUHFBSZBs/Gcc8wFJse4RVuy1bftmz9hLWdpErR74q/cWgYFuQ3VB7LQmW80+gibTSMtkes7iCcZD3JM85+E8Zrx0C1G9aOug2RQPBJsAoWwhgDD11PVi/7rBJ0C+/G3IyQn7nTt/s9zt8vdBWmMxggPx712pFWlgRSk4ABS+GICY8BMPz8xG85zHt9WULDgci44CoBCAyXrseabuu7pPb8YAp8rTfhRwgbVvpADovvYKBc/wBhZ5638H6dbmU92+7LWNXhwIrqC7MgnHOA+hsCIYFr6m7mP5NREREbmunVcPUb8eCU+d3TVIzsb+tP8Kg+jRP/rYZx7IK0DIuEo+c39EzOyGzwbmpQF4GkJvucJle9n0SDFcWAFeXzLiG1ddmUcPra8FW1hEtTbakEMg6DGPWYfQG0Fv/9C/x5Cfa1eCIOAwKaojsRbvw6PbWmHtIm/Uf26epSquPMAVXP2133xJg3ZfA1l+1QLa6JIiNTgaiErXL6CT7Zo1KxKQ5qfh9Twk6xjXED3cMLJ3dUWJ2PlGhTl7IbdsmQb8EmXkZKMlJw5GdG9G4QTiC8jO0IFR+lsW2AF9+7rI5KLYakYZ6iGnYGFFxjbWgUvZVbbbrEmBKsHtiP3BiH3DSdim3Tx7QAv/je7StRgw1/l2TEwtJ+kvJUvwiIEJun74sP82FFwuJPBVgy9+CvOfy9ju2FZDQEUjsDCR00jbJEtADaP2kgZcJrKDadpbEaDXDImevQkLsFTrTmP5NRERENW2nVcPK347GdGukguo/Nh/Ds5d0qZMewF5HpkplplICBINRzRLO3ZqKn9YeQpDBgFeu7I5wk7H290FmFlM2aTNrx2yX6dsrnEEtl8zuScqx46UEC/aUZP1SvmbbJGCWYNl+Wc/5ujy/vKA2Nw3IPKgFberyIHJT9yDt0C40NKci2pAPQ1464pAOLHsa0wFsCG0DY5eL0fmcTrLIv+rvUdYxr/8KWP+19j11DdsCjXsDJkm7jtA+m8umXy/rPtki4rRZyHJIiPXw2AIseO0vbDiUiXf+txv3DGvr/CBjMGCMBkKjK919S3Ex1hTPRtKoUQgKcVhWIMG3HmCrWVWDCurfX5ODqYuOoVOj+vj9rjMrD/oa9Szjm5bYToQ4BNoq8D6gnQSQ2EU2OZlTctpW6vfQFlDLGIY3cN4kQLXfjj11n6S/Oz5XrT234tV527FoeyqS64XhiiY5GHrmQAQbbX9zknUhJ41y02ybnGxI19K41f2ptuyLXOCkbPtP7aKcZJCAWQXPHbXr8R203w0fFGBBtf7LIr8EeUBYJGeqiYiIyI3ttNzXzkmKQUlbpJSsQizekW7vX+128uF531ItHVMYgmybpHjKbJ/B+bb9PoMW8Dh+OJdNgpeqkFRQFUjIbJ1txs7xukpxPuU8APvCAAuCEDRTC7TVOlQVdMv+GbVA1J6WKrOE8bZL2xYaixBzdumiVZJ2raelqgB6o3ZZXlqqfG8J+OR7qTW3+nXbbf26umyojVNVx6cmZDyiZWY3EWjSx363TDMFm0vwwuxt+H75JjQxpKNP0HaMMq5Ev6Bt6GbYBWx+WdtkXWqni4BOFwMNW5f/vQqygC0/a7PSB1acuj+0HtD1MqDHtVpAXUuzjFIY7JmLu+Cer9fhrYU7VeXzrk3qufebyAmPeo21zaaguATv/bsQVgTh1iGtqr/mXH6HJfVbthZnVu25cvLEKcguAcJitP2toZvGdsF3ry/GhpMFSA+24IzEnogKD63CSbEcLeCW9eRyKfuV0BmIlPR5/xFYQbUxBFZjKAySBiM/YMRzTTURERG5L/3bjUG1tP4c1TUZHy/bh983HHF/UC3psBIELXsDOKatT3aL0BhtBtUx0NZnx+RrKv3TFjTLZTnrWisTBIsWTNjXyp4m61C5zw2xVdexbr7nVNAtM4DpOwBrSeknyImEhm20WTW1ddUu6zXxylRUV0jmw5QLO2NQ2zg88N16fJrXAqEDbkOvM2Nh2jkb2PKLlrotVZRlW/A0kNjFFmBfBMS3t6V3L9YC6S2/aunU+ni1PgfocQ3QfrQ2614HLuzeSGV2zN54TBXY+u2uMxEWUruZDD+sOaRqHzSuH47RXbUe83VOTp4E2bIb3Eza+0mbrXEzVmJ1ehCufP8ftca+VbzDZGV55G9DMgNkk7RuPxZYQbWQM6r5ElTnOvWSTM8phMViVQcwIiIiomr1qI5x74faMd2S8Nuy9fhzSxDyi0rck+osn4HWfAb8PU2bCdbTRFudbas8bNVmmNRm0Tbo1x3uk01eSy94JEW0hMwsy6a/tisk4K7fzFacqfmpIk1yX0xjtV8/rTmAKT9tQJjRgs9v7Iv2CRHajJykvkogLAGeuizR0nT1dFSVipp2qvpybiqsOakwFJyEQZ6bfUTbdJJWnWQLmtXWxafTUitzbsdEzL/3TPw0ez4mjGyHEEl37nuTtkkK77ZZWoC99y9bCvwm4H/PamMiP3/H9O64dlog3W2sVsm6jsks8X8v7oqVe09gZ2oOXp2/A4+Oqr019xI7fLhkr729l9RC8EeD28bjvWt74r6v12DL0Wxc8NZSPHNRF1zWW8qzUYAG1VHqP36DLaiWKp1yEsVsseJ4XpG6TURERFS9NdVu+Bwh6yj3LFJbzz1/YVXYcRyxxiLty3PRrN8YoOVZ2kxwFZmKsxC0aCqw+iOterSQ1OT+t2sBlMwm14QEsxJYl1VZWL9Pvq/MYNsDZ7lspq0LrsDhk/mYMnsfshGB24e1R/vWNZv1MhcXY87vv+L8IX0QUiDFxKTakkELoiUY9NHZ55rMRiaUlSksaeu9x2ub/Ay3z9EC7N0LTy0XqKP0blfFRprw/KVdcfOnq1Tf6GEdE9GvZe301Z6/NQV703MRExaMsX2bwp+d3T4eD3UrwewT8fhn7wnc/916LN2VrlLuo0IDL6Q8XeCNgF7SvVgrGy+VAWMjtJYVkgLOoJqIiIiqKi2rBunfuRlaCq0tkHasjKuHJ40Mx4F932mbrBlu2g9ocy7QZhiQ1F1L/yxPxm4ELX0DIzZ/CaPVliotqZjSx7X71W5Zd6nILLdaVxzr9tnAh7/fgOxCM3o2q4/bhrgnjdQq66ElgG7Y3C2v5/fk59rzWm2TSua7F2gtoNqOqLP0blcN65SIK3o3wXerD6nU9jn3DEZkLQR+HyzWqnRfe0bzgAgs64cCn0zogw+W7sdrf+7AT2sPY+2BE3jr6l7uX7/uY/z/p38aqylSO0DpvdhsKeAqqM4uQCfUsAcfERERBRSr9HPNsc1Uu5L+LanJUshJD6KPynpmh4JZEuw16Qe0Gqq2LSWN8fwHn+Kc4A0YF78LQRk7tefLtvC/2myzrF+VAFsuZX2wOPgvsPwNYOvvMNpe39KoF4LOvA/oMNqW6u39Pv9nv5oRCwsJwitXdPfbFFufIpkSXS6DN5syppPq8X7geB6em70Vz17S1a2vv3r/CazafwImYxBuGFi3PZE9yRhkwF3ntsUZrRvinq/WYl9GHi59dxkePq8DbjqzZfULtfm4AJ6p1tK/9QPgtmPZrABOREREVXYirxjFJVrQGl9RxptUkZ73GLBvmdY72JFUw7UF0Wg+wKntT0erFQdjB+LJ9O5oMLgHLmpu1mYJdy0A9vylFf7a+K22ieQeWoulg//YX8PSZgSWG/qg/xX3IchUfmsibyOptRIQiUfO6+BacSQiANFhIXjpim645oN/8MU/BzCic5Jb+72/v3i3ury4ZyPXTqb5GelOMPuewXj4hw34Y3MK/jtrqzqJ8dLl3dAwADN/A+9Un62tlr6m2jFVK41BNREREVWz8neDiBCYgsv5aLXpB+DDYdpaVAmopfhWj+uASz8E7t8B/Gc5cN5zQLsRpfroyszPBd20qsK/rT+irUPucyNw1RfAw3uBCbOBMycBSd20JxxdpwXUkpor3+M//6Bk7JfIiOrg8fWuVVFiseL+b9ehoNiCga0bYtyAwJkNJPcY2DoOE2yzyA99vx6ZeeVUiq/GyZ55W1LU9VsG+3dV64rUjzBh+nW98cxFndX/fQu3peL8N5Zg+e5yWtD5scCdqVYttTT2XtW29VBEREREVe9RHVZ226oFTwLL39Juy0z0+S8BcW2rFOCO6d4Iby3chb92pKnAoF5EiL1dKFoM0rZhTwDZKdosdl6Glp6rV2Audk8wUZfeW7wbaw6cRHRoMF66ojs7tFC1SFry4h1p2JOeiyd+3YTXr+pZ49f8cMkeVQhfemG3TXQ+CRZo5KTf9QNaoE+LWNz11VrsSs3BtR/+g4lnt8E957YNmOUaVXqX7777Lrp164aYmBi1DRgwAHPmzKnwOd999x06dOiAsLAwdO3aFbNnz4YnWUP0oLr0TDXTv4mIiKjalb9jQksXIPv80lMB9aB7gGt/AOLbVXnGuF1iNNolRqk08z+2HCv/gdGJWksjKULmgZZG7rL1aBZem7/DvjZWegATVYe0oXv5yu6QczI/rzuCORuP1uj1MnIK8f1qrQd6IM9Sn65jcgx+nTgIY/s0VScc5CTgVe//rSr3B4IqBdVNmjTB888/j9WrV2PVqlU455xzcNFFF2Hz5s1lPn758uW4+uqrcdNNN2Ht2rW4+OKL1bZp0yZ4TGhU6aDatg6CQTURERFVN/1bCp/aHVkLvH+W1ttXTuhfMRMY/jRgrH6S4JhuWpD8+4aaBQXershswaRv16sTCNIO6XL2wqUa6tWsAe4Y2lpdf/SnjTVa8vnpiv0oNFvQrUk9nNGqdlp1+aoIUzBeuLwb3rq6p8owkUJu57++GHM3+ff/WVUOqseMGYNRo0ahbdu2aNeuHZ599llERUXh77//LvPxb7zxBs477zw8+OCD6NixI5555hn06tULb7/9NjwmpIL0b9tBkYiIiKja6d/rvgQ+GglkHtRaV938J9D5khp/nwu6a0H1sl3parbMX72xYIeaqZY16lMv7Rqw1YTJve45t52aTZXCgpN/3Kiq9ldVflEJPl2htby7dUgr/m5WsFxl1t2D0b1pfWQVmHH752vw2M8bUVBcAn9V7dOlJSUlKrU7NzdXpYGXZcWKFZg0aZLTfSNHjsTPP/9c4WsXFhaqTZeVlaUui4uL1VYTVmMYpIGEtSDb/loNwo32g2JRUVFA/YHoY1DTcfUnHBNnHA9nHI/SAnFMAum9UuX0Wa+kyCBg1gPAvx9oX2h3HnDJe1r7ITdoGReJzo1isPlIFuZuPoZr+/tff2XpefvuIq2qsrRAcpr9J6oBKaT16pXdceHbS/Hn1hSVwn1Fn6ZVeo3v1xxSQXmTBuE4r3NSre2rP2jWMALf3TYAr8zfjvf+2oPP/z6AVftO4O1reqJNgv+tQ69yUL1x40YVRBcUFKhZ6p9++gmdOnUq87HHjh1DYmKi031yW+6vyNSpU/HUU0+Vun/evHmIiIhATTRLPwApT5B2ZB9W2tZ3F6mTJsEqleOH3+YgIvDKt2H+/Pme3gWvwzFxxvFwxvEI7DHJy8vz9C6QF5FMt3icxIXrbwMy1mh3nvUIcNbDQFCQ22eAJKj+ff1RvwuqZRbw/m/Xw2IFLurRCKO6ahXPidxFZqrvG94OL87djqd/24KBbeJcXq8v1eilQJm4+cyWAVOAq6YnMiaf31FVYZdK/tLC+IK3luLJMZ0xtm9Tv5rIrHL42L59e6xbtw6ZmZn4/vvvMX78ePz111/lBtbVMXnyZKcZbpmpbtq0KUaMGKEKpNWEZUMucHAGEupFqFR23dMbFiK7wIweZwxBm4SogJptkQ/Cw4cPR0iIrZJogOOYOON4OON4lBaIY6JnUBGJ+JPr8Xbo84jNOAmExgCXvg+0P79Wvtforsl4fs42/L03Q3Ut8af+uC/M3aYqNCfGhOLpC7t4enfIT902pDX+3JKiKstLm63PbuzvUmX5+VuOYX9GHuqFh1R5hjvQndUuXvW0lpNmS3am45EfN2LprnQ8d2lXxISFBGZQbTKZ0KZNG3W9d+/e+Pfff9Xa6ffee6/UY5OSkpCSovVw08ltub8ioaGhajudfFir6Qc2c7gWlBuK85xeS9ZVS1B9Ir8kYD4Uunts/Q3HxBnHwxnHI7DHJFDeZ0CZ8wiwbwkQlQhEJ2lblO0yOlmrqi1fC3b4fGK1wrpqBl7P/z+YDCUoim0H0zVfAXHa56Ta0DQ2Aj2b1cfaAycxe+NRTBjUEv5g+a50zFyurVV94bJup1qGEbmZMciAV67sgVFvLMGyXRn47O/9GG/rZV0eWX/93mJtlvr6M5ojMjQA01prKCE6DJ/c0A/vL9mDl//Yrgourj90Em9e1RM9mzWAr6vxb4TFYnFa/+xI0sQXLFiAe++9136fzGaUtwa7Tpi0WWhD8anq3/oPendaLiuAExERBZqiPOCfd7XrKZV0KAmPPRVkW60w7PkfTAZgVkk/nH3DtzBF1/6Hwwu6NVJB9W8b/COoziooxoPfb1DXr+nfDEPbJ3h6l8jPSX2CyaM6YMovmzF1zlYMbhuHVvHlZ6pKFWv5mzMZgyoNwKl8khFw+1mt0a9lLO7+ai0OHs/HFdNX4P4R7XHbkFY+3Ys+qKpp2YsXL8a+ffvU2mq5vWjRIlx77bXq6+PGjVP36e655x7MnTsXr7zyCrZt24Ynn3xSteKaOHEiPMVqslX/LjxV/duxtyQrgBMREQUYhzabuGgacM7jQN9bgI5jgCZ9gXrNgCDbzGn+cSB1M7B7IbDnf7AagvB88VV4OOh+RNRBQK2ngMtSxNX7T/hFD9hnftui3kez2Aj836iOnt4dChDX9W+OM9vEoaDYgvu/Ww9ziaXcx75vm6W+tFdjFs9zU4uzWXcPxuhuyTBbrGrpx/iPV9ao1ZlPzVSnpqaqwPno0aOoV68eunXrhj/++EOtoxMHDhxAkENBjoEDB+LLL7/EY489hkcffVS14pLK3126eHCdjB5Ul5qpDnVqi0FEREQBQm+zKW03e15X9mOk/U7ecSDnGJB9FMhOAXJTsSm4G6b/XIBWDepubXNSvTD0bRGLlXuPY9aGI7h1iNZ/1xfJ2tbvVh9SJwlevqI702qpzsis6IuXd8PI1xerWWhJ777z7NJLN3an5ahq4eLmwa08sKf+qV54CN6+uicGt4nDk79tVmutz39jiarQPqRdPHxNlf7n+uijjyr8usxan+6KK65Qm9ewpX+rs9JygLRVndN7S6b5cd9HIiIiqmCmWj/xXhb5vBDZUNsSO9vv3rPusDSmrvPZK6kCLkG1rEv01aD6eG6RKlgkbhncSqWEEtWlRvXDVSVqmal+/c8dOLt9Ajo1ci6K/OGSvSpkGNYxIaCKGdcFg8GAq/o1Q+/mDTDxy7XYnpKNcTNW4razWuGBEe0R4kMV1n1nT929ptpiBkqKSqd/c6aaiIgosLgSVJdDT1es6yrc53dJgiw/3HAoE/vSnbPvfIEUfnrs541IzylEu8QoTBreztO7RAFKUrpHdEpEcYkVk75dh0Kz6rWryO/nD2sOqeu+evLKF7RNjMYvEwfh2v7N1G3pa3359BU4kOE77SsDL6gOcehz7bCuWj/DzDXVREREAZr+rWezVSeoruOZ6rioUAxqE6euz9p4FL7m1/VHMHvjMQRLJeYreiAsxOjpXaIAni2V1k6xkSbVR/mNP3fav/bZ3wdRZLage9P66NvC9ytUe7OwECOevaQr3r22F2LCgrH+4EmMfnMJflt/BL4g8ILqICPMBpPzQdQh/ZvVv4mIiAJMDWaqUz0UVIsLuiWrS1/50KlLySpQVZfFxHPaoGuTep7eJQpwcpLquUu0mk/T/9qNtQdPorAE+HLlQXWfVKaW4Jtq3/ldk1VPa0kJzy40466v1uKRHzYgv+hUBoE3CrygWnpVG8NKVfvU07+lV3VBsXf/0IiIiMhbguoCp88RdWlk5yQ10yuza7tSs+Erad8Pfb8BmfnF6Nq4XpmFoYg84bwuybikZ2NYrMDDP2zC0mMGnMwvVlXp5W+N6k6TBhH45tYzMPHsNqqcxdf/HsSYt5di27EseKuADKpLgsJKzVRHhwYjLEQbDq6rJiIiCsT072oE1bbPDHrGW12qH2GyV8n9bb1vpIB/tfIg/tqRBlNwkKry60uFiMj/PXlhZyTFhGFvRh5+PaAtSbh5cEsYfbh/sq8KNgbhgZHt8cVN/VUm0K7UHFz49jJ89vd+dXLO2wTk/2TmoNBSQbWkdJxKAee6aiIiooBRnFftNdWeTP92SgHfcMQrP2g6WnPgBP47a4u6/tDI9qo4EZG3tXmSNlu6BhEhuKJ3U4/uU6Ab2CYOc+4ZjLPbx6v17Y//vAm3f74aJ/NOFZz2BoEZVJeR/u3Uq5rrqomIiAJHNdO/ZbmYpDF7aqZaDO+UqGZ996TlYutR70wBt1iseGfRLlwxfQXyikrQv2UsbhzU0tO7RVQmyf64/gytCvUNA5sj3MQiep7WMCoUH43vi8dGd0SI0YAVuzOQU2iGNwnMoFpP/3ao/u3cVosz1UREFNimTZuGFi1aICwsDP3798fKlSsrfPzrr7+O9u3bIzw8HE2bNsV9992HgoICvw6q9crfEtTGhAfDE6LDQtQMjj5b7W0k+0/6zr44dztKLFbVX/uD8X0QxHRa8mKPnd8eD3Uz47bBPPnjLYKCDLh5cCv8eMcgvHFVT7Xu2psEZFBdYp+pPi2oZgVwIiIifPPNN5g0aRKeeOIJrFmzBt27d8fIkSORmppa5uO//PJLPPLII+rxW7duxUcffaRe49FHH4U/t9RyTP32ZGVgCVTF716WAr5oeyrOf30Jlu5KR3iIES9e1g1vXtUDMWEhnt41okoDuMaR2iV5l65N6uHsDgnwNoE9U31a+vepXtUMqomIKHC9+uqruOWWW3DDDTegU6dOmD59OiIiIjBjxowyH798+XIMGjQI11xzjZrdHjFiBK6++upKZ7d9f6a6wKPrqXXndEhQQevB4/lYfygTnibrHp+bvRUTPv4XGblF6JAUjd/uGoQr+zZlWyIi8kueyVXywkJlgmuqiYgo0BUVFWH16tWYPHmy/b6goCAMGzYMK1asKPM5AwcOxOeff66C6H79+mHPnj2YPXs2rr/++nK/T2Fhodp0WVlaq5Ti4mK11YT+fFdfx1iQrWYZpOaKtQrf++hJrcBZXJSpxvtcEyEGCazjMWvjMfy69hA6J0XWeEyq68DxPNz37QZsOKz9PK/r3xSPjGyH0BCjR8fIU+PhKzgezjgepQXqmBS7+H4DM6gur1BZjC39m2uqiYgoQKWnp6OkpASJiYlO98vtbdu2lfkcmaGW55155pkq/dhsNuP222+vMP176tSpeOqpp0rdP2/ePDUr7g7z58936XEDjx6ArEpet2UnDh+d7fLrrzggoXgQ8jOOqZMInpRUJDPARvywah+6WnajvKxVV8ekOlanG/DNniAUlhgQYbTi6jYWdAvaiwXz98Jb1eZ4+CKOhzOOR2mBNiZ5ebbuEJUIzKC6jD7VjjPVeuERIiIiqtyiRYvw3HPP4Z133lFFzXbt2oV77rkHzzzzDB5//PEynyMz4bJu23GmWgqcSep4TExMjWcW5IPf8OHDERJS+fpd48evAzlAj36D0L3tSJe/z5KfNgOHD6NPl3YYNbQVPOnc4hJ888JfyCw0I6nLAPRp3qBGY1IVeUVmPDNrO77feVjd7tO8Pl69ohuS63mmIroranM8fBHHwxnHo7RAHZMsWxZVZQIyqC4pr/q3LaiW9T/FJRaEGANyyTkREQWwuLg4GI1GpKSkON0vt5OSksp8jgTOkup98803q9tdu3ZFbm4ubr31Vvzf//2fSh8/XWhoqNpOJx/W3PWBzeXXsvWpDg6vJ09y+fXTc7U+qcn1Izz+IVO+/4jOifhxzWHM3ZyKAW3KLuTjzvEVW45k4a6v1mB3Wi5kufRd57TF3ee0QbCPfIZy93j4Oo6HM45HaYE2JiEuvlff+B/PzczG0DLTvxtEmBBsy5dKz+FsNRERBR6TyYTevXtjwYIF9vssFou6PWDAgHLT404PnCUwF95UjdrdhcpSs7TPCvG2lpyeNqabVgVc1lZL+6raJD/XT1fsw8XvLFMBdWJMKL68+QxMGt7OZwJqIiJ3CciZ6vKqf0vZfKkAfjSzQB0ok+uFe2YHiYiIPEjSssePH48+ffqowmPSg1pmnqUauBg3bhwaN26s1kWLMWPGqIrhPXv2tKd/y+y13K8H1/7cUis+yjuC6kFt4lA/IkRNDPyzJwMD28TVyvc5mVeEh77fgHlbtGyGczsk4KUruiM20lQr34+IyNsFeFDtnP6tp4CroJrrqomIKECNHTsWaWlpmDJlCo4dO4YePXpg7ty59uJlBw4ccJqZfuyxx1SrJLk8fPgw4uPjVUD97LPPwidUY6baXGJBRq6tT7WXzFSbgoNwXuckfP3vQfy24UitBNUr9x7HvV+vxZHMApiMQZg8qgMmDGzBVllEFNACvPp36aA6Plq+lolUW+9JIiKiQDRx4kS1lVeYzFFwcDCeeOIJtfkccxFQoq2Nhsn1quNSf0Uy22XVWMNI7wiqxZjujVRQPWfTMTx9URe31YeRdPK3F+7CGwt2QDLLW8ZF4q2re6JL43pueX0iIl8WkEF1ib1PtXP6t+PZZn2dFBEREfmxYofPAiGuz1TrnxPiokJhLK9/lQf0bxmr+man5xRh6a50nN2+7IJlVXE0Mx/3fr0O/+w9rm5f2quxCtijQgPyYyQRUSkBWUnCbAwvP6i2VQBn+jcREVEA0D8LGE1AsOtrgvWMNm9J/dZJkbBRXZPV9d/XH63x6y3YmoJRbyxRAXWkyYjXxnbHq1f2YEBNRIRAD6rtM9U5Ur7S6WsJKv1belUz/ZuIiMjvVbfyt+3ku/65wZtcYKsCPm/zMRQUl1TrNQrNJXjqt8246ZNVOJFXjC6NY/D73YNxSc8mbt5bIiLfF6BBte0AaLUAxflOX+NMNRERUQCpbuVvW/q3/rnBm/Rp3gBJMWHILjRj8Y60Kj9/T1oOLn1nOT5etk/dvunMlvjhjoFqHTUREZUWkEF1SZAJVhjKTAHnmmoiIqIAUu2Z6gKvDaqlRejobloK+G8bqpYC/sPqQ7jgraXYfCRLtciaMaEPHr+gE0KDfaA1GhGRhwRkUA1D0KkKn0XZTl/S07ikx6NFylsSERGR/6ph+nd8jPelf4sLbEG1rInOL6o8BTyn0Iz7vlmH+79bj7yiEgxo1RBz7hmMczpobdSIiKh8gRlUO1b4PG2mWipmSqtFs8WK43m2FhtERETkn2q8ptr7ZqpFj6b10aRBuAqQF25LrfCxGw9l4oI3l+CntYdVJfMHRrTD5zf3R6KXnjAgIvI2gRtUh0aVGVRL1cyGkVr1T6aAExERBUpQXbU11WlZ3pv+LQwGg71g2W/rj5T5GKvVig+X7MGl7y7Dvow8NK4fjm9uPQMTz2nrVW3CiIi8XeAG1fpMdaGtQImDeFsKuL5eioiIiPxUNWaqJRhNy7HNVHvxbO6Y7loK+P+2pyK7wOz0tYycQtw481/8d9ZWFJdYcV7nJMy+ezD6tIj10N4SEfmugG0yaDVFaqXK9KqfDuSs89ajrABORETk96oRVEuLKQlERXyUd85Ui07JMWgVF4k96bkqBTzEdv/y3em49+t16nOOKThIFSK7rn8zNbtNRERVF7gz1aay078dU7nSGFQTERH5t2q01NIz2RpEhKig1FupFPDuWgr4rE3HIOcBXvtzF6798B8VULdJiMIvdw7C9Wc0Z0BNRFQDATtTbT8jXdZMtb2tFtO/iYiI/Fo1ZqpP9aj23tRv3ZhuyXhzwU4s3ZWBfRFG7M3eo+6/qm9TTBnTCRGmwP0oSETkLoH7P6l9prqs9G99TTVnqomIiPxadYJqvfK37SS8N2ubGI0OSdHYdiwbe7MNiAoNxtRLu2KMbQabiIhqzntzlupgTXVl6d8MqomIiAIl/bsqQbWWyRbvpZW/T3d57ybqsnmUFb/eeQYDaiIiN+NMdVlBtZ7+zerfRERE/q0aLbV8Kf1b3DCoJfo1r49da5agaYMIT+8OEZHfCdiZavsZ6cIK0r+zClXbDCIiIvJT1Uj/1guZemuP6tNJz+mOydEwshYZEVGtCNygWu9TXcaaaj2dq9BsQdZpfR2JiIgo0NdUF/jMmmoiIqp9ARtUW0PLT/8OCzEiJkzLjE9jCjgREZH/qlZLLd9K/yYiotoVsEF1RS21RELMqRRwIiIi8lP6yfUQ19Yay7KwU2uqOVNNRESBHFRXkP4tWAGciIgoAFQx/Tun0Iz84hJ1nenfRERU5aB66tSp6Nu3L6Kjo5GQkICLL74Y27dvr/A5M2fOhMFgcNrCwrwgXaqC9G/noJrp30RERH7JYgGKq1b9Wz/ZLv2eI0yB20SFiIiqGVT/9ddfuPPOO/H3339j/vz5KC4uxogRI5CbW3ZgqouJicHRo0ft2/79++Fp1pDyq38Lpn8TERH5ueK8U9ddnKlm6jcREZ2uSqdY586dW2oWWmasV69ejSFDhpT7PJmdTkpKgneuqa5spppBNRERkV+yfwYwACHhLj1Fz2DTO4UQERHVKG8pMzNTXcbGxlb4uJycHDRv3hwWiwW9evXCc889h86dO5f7+MLCQrXpsrKy1KXMjMtWE/rzi4NCEaKu5KK4qBAwOE/aNwjXhiYlK7/G39Ob2cfDj99jVXFMnHE8nHE8SgvEMQmk9xowlb8Nhqr1qLZltBEREVU7qJYA+d5778WgQYPQpUuXch/Xvn17zJgxA926dVNB+Msvv4yBAwdi8+bNaNKkSblrt5966qlS98+bNw8REa5V56zMgiX/YIz+ur//BLPR+Qz13kw5uBqx9+hxzJ49G/5O0vnJGcfEGcfDGccjsMckL88hbZgCrEc107+JiMhNQbWsrd60aROWLl1a4eMGDBigNp0E1B07dsR7772HZ555psznTJ48GZMmTXKaqW7atKlavy3rs2s6uyAf/M4dMQrWDUEwWC0YMXQQEO2cnr47LRdvb1mGPGsIRo0aCX+lj8fw4cMREqLm7gMex8QZx8MZx6O0QBwTPYOKAjCoztLSvxlUExFRjYLqiRMn4vfff8fixYvLnW0uj3zg6tmzJ3bt2lXuY0JDQ9VW1nPd9YEtxGSCQdK9CrMQYi2SF3f6eqPYSHvrDLM1COEmI/yZO8fWX3BMnHE8nHE8AntMAuV9+r2azFSznRYREVWn+rfValUB9U8//YSFCxeiZcuWqKqSkhJs3LgRycnJ8Di9fUZhdqkvRYcGIyxEGx621SIiIvJDVWyn5Zz+zTXVRERUjaBaUr4///xzfPnll6pX9bFjx9SWn59vf8y4ceNU+rbu6aefVmuh9+zZgzVr1uC6665TLbVuvvlmeHMFcKlYrh8wWQGciIjIDzH9m4iI6jr9+91331WXQ4cOdbr/448/xoQJE9T1AwcOICjoVKx+4sQJ3HLLLSr4btCgAXr37o3ly5ejU6dO8IW2WgeO57FXNRERkT+qYlBdUFyCrAKzus6ZaiIiqlZQLenflVm0aJHT7ddee01tXik02rmlxmn09VJM/yYiIvLzllpVaKdlCg5CjK31JhERUZXSv/2Ofaa6nKCa6d9ERET+q4oz1fpJdslkk2ViREREgkF1Benf8bb1Ukz/JiIi8kNVDaptnwe4npqIiBwFeFAdVclMNdO/iYiI/D/929WZalb+JiKi0hhUi8Ly1lSHOa2hIiIiIn+cqY6qWvo3e1QTEZGDAA+qK6/+LbimmoiIyA8x/ZuIiNwgsIPq0CiXgurjuUUoMlvqcs+IiIiozoLqCJcezvRvIiIqS2AH1faZ6uwyv9wgwoTgIK26Z3oOZ6uJiIgCuaWWHlTHM/2biIgcBHhQXfFMdVCQ4VQFcKaAExERBXT6d5pDSy0iIiJdgAfVFa+pdlpXncUK4ERERIEaVJtLLMjILVLXmf5NRESOAjyorrj6t4i3HTg5U01ERBS46d/pOUWwWgFjkAENI021v29EROQzGFRX0KfasW0Gg2oiIiI/IhFyFWaq9XZacVEmtTyMiIhIF+BBtevp3/o6KiIiIvIDJUWAxex6UG1vp8XUbyIichbYQXWoCzPVevq37WBKREREfsDxhHqIKzPV7FFNRERlC+ygWk//NhcAJbaz1eUVKmP6NxERkf/QT6gHhwHGYJfTv/VlYURERLoAD6odzkwX51aypprp30RERIHaTsveo5rp30REdJrADqqDQ4GgkArXVevp31L1s8Rircu9IyIiIm8Jqu1rqjlTTUREzgI7qHY8mJbTVkuqfBoMUAH1cVt/SiIiIvKXoLrydlqOBUsZVBMR0ekYVFfSVivYGGTvR8kUcCIiosBO/06IYfo3ERE5Y1BtrwBeflstff0Ui5UREREFXlBtsViRxurfRERUDgbV9l7VOZX3qmZbLSIiIv+gH/ddSP8+kVcEs62uSlwUg2oiInLGoNoeVJc/U32qrRbTv4mIiAJtplrPVIuNNMEUzI9ORETkjEeGStZUO7fV4kw1ERFRoAbVTP0mIqKyMKjWg+pyqn87ttXS22kQERGRv6R/uxBUZ2mZavEMqomIqAwMqpn+TUREFHiq0FLr1Ew1K38TEVFpDKpdKVTG9G8iIiL/DKpDIip9qL3yt+3zABERkSMG1aHRLlT/PtVSy2rVqn8SERFRYKR/s50WERFVhEG1C+nf+hqqIrMFWfnmutozIiIi8or0b235F9O/iYioLAyqXQiqw0KMiAkLVte5rpqIiChAq38z/ZuIiMrAoNpkS/8uzK7wYQkxp1LAiYiIKDCCaln2pXf/YPo3ERGVhUG1CzPVghXAiYiI/HFNdcXp3zmFZuQXl6jrTP8mIqKyMKiualDNXtVEREQBM1OtZ6hFhwYj3GSsiz0jIiIfw6A6NMq1oJrp30RERIEXVNtOpsdzPTUREZWDQbWe9lWU7dJMtd5Wg4iIiHyUpQQw57uU/n2q8jeDaiIiKhuDahfTv/W2WlxTTURE5OMcj/mVzFTrJ9PjuZ6aiIjKwaBaP5iWFAHmonIfphcnYfo3ERGRnwTVBiMQHOpaOy3OVBMRUTkYVDumfemVQMug96ZMY6EyIiIiP1lPHQUYDBU+NDWL6d9ERFQxBtXGEMAYWmkKuH4wzZbWGkVaaw0iIiLyQcWuFSlzmqlmoTIiIioHg2oX11VHSSuNEK2VBtdVExER+X/lb+f0b66pJiIiNwTVU6dORd++fREdHY2EhARcfPHF2L59e6XP++6779ChQweEhYWha9eumD17NryzrVb56d8Gg8F+lprrqomIyN9NmzYNLVq0UMfu/v37Y+XKlRU+/uTJk7jzzjuRnJyM0NBQtGvXzvuO99UJqpn+TURE7gyq//rrL3XA/PvvvzF//nwUFxdjxIgRyM0tf4Z3+fLluPrqq3HTTTdh7dq1KhCXbdOmTfC+tlrlB9WOB1S9ZyUREZE/+uabbzBp0iQ88cQTWLNmDbp3746RI0ciNTW1zMcXFRVh+PDh2LdvH77//nt1wv2DDz5A48aN4ZX0430l7bQKikuQVWBW1zlTTURE5QlGFcydO9fp9syZM9WM9erVqzFkyJAyn/PGG2/gvPPOw4MPPqhuP/PMMyogf/vttzF9+nT4UlutUxXAmf5NRET+69VXX8Utt9yCG264Qd2W4/WsWbMwY8YMPPLII6UeL/cfP35cnUgPCQlR98kst9dycaZab6dlCg5CTHiVPjIREVEAqdERIjMzU13GxsaW+5gVK1aos92O5Gz3zz//XO5zCgsL1abLyspSlzIzLltN6M93fB1jSKSasjfnnYS1gtdvGKl9UDh2Mr/G++EtyhqPQMcxccbxcMbxKC0Qx8Sf36vMOsvJ8smTJ9vvCwoKwrBhw9QxvSy//vorBgwYoLLZfvnlF8THx+Oaa67Bww8/DKNRq0fi6WO9o6D8LMheWULCUVLB9zpyQgu+E6JMMJu1GWtfFYh/pxXheDjjeDjjeJQWqGNS7OL7rXZQbbFYcO+992LQoEHo0qVLuY87duwYEhMTne6T23J/RWu3n3rqqVL3z5s3DxEREXAHmS3X9T2ejUYANq9diX0Hy08FO35E2m4YsXbbbsw274Q/cRwP0nBMnHE8nHE8AntM8vLy4K/S09NRUlJS5rF727ZtZT5nz549WLhwIa699lq1jnrXrl34z3/+oz6MSAq5NxzrHbU9tgadABxMOYF1Faz7XpehHfeDzfneuz68igLp79QVHA9nHA9nHI/SAm1M8lw83lc7qJaz0bIueunSpXA3OTvuOLstZ6+bNm2q1m/HxMTU6LXlAC+/DLL2S09RM/76O7BxNbq0a4FOZ4wq97kFaw/j9wObYaoXj1GjesMflDUegY5j4ozj4YzjUVogjok+q0qnTrTLcrD3339fzUz37t0bhw8fxksvvVRuUF3Xx3pHQf9bCxwFmrRqj0Yjyj/uZ/x9ANixDe2aJWLUqB7wZYH4d1oRjoczjoczjkdpgTomWS4e76sVVE+cOBG///47Fi9ejCZNmlT42KSkJKSkpDjdJ7fl/vJI1VDZTic/QHf9EJ1eK0w7eBvN+TBW8PrJ9bW1V+k5RX73y+TOsfUXHBNnHA9nHI/AHhN/fp9xcXEqMK7KsVsqfsuYOKZ6d+zYUWWlSTq5yWTy/LHeUUm+ujCGRVd43M/I09L+kuqF+83PPJD+Tl3B8XDG8XDG8Sgt0MYkxMX3WqXq31arVQXUP/30k0rzatmyZaXPkTVWCxYscLpPznLI/V7D1UJlbKlFRER+TgJgmWl2PHbLTLTcLu/YLUvBJOVbHqfbsWOHCrbLCqi9p/p3xYXK9G4fbKdFRERuC6ol5fvzzz/Hl19+qXpVyxlo2fLztTO+Yty4cU7FTe655x5VNfyVV15Ra7GefPJJrFq1SgXnvtdSS6v+fTy3CEXmUx8ciIiI/ImkZUtLrE8++QRbt27FHXfcodpn6tXATz/Wy9el+rcc8yWYlkrhzz33nPrc4N3VvytuqaWfRGc7LSIiclv697vvvqsuhw4d6nT/xx9/jAkTJqjrBw4cUFVCdQMHDlRB+GOPPYZHH30Ubdu2VZW/Kypu5rmguuKZ6gYRIQgxGlBcYkV6TiEa1Q+vm/0jIiKqQ2PHjkVaWhqmTJmiTp736NFDnSDXi5edfqyXtdB//PEH7rvvPnTr1k31p5YAW6p/+3JLLT2ojrdlqhEREdU4qJb078osWrSo1H1XXHGF2ryWflAtrHim2mAwID4qFEcyC9SBlkE1ERH5K8koKy+rrKxjvaSG//333/AJLvepLlCXTP8mIiK3pX/7Lfua6oqDahEfo6WApWZpB1oiIiLyMfY11eWnf5tLLMjILVLXmf5NREQVYVBdhfRvITPVgsXKiIiIfJQLM9XS6UMS9IxBBjSM9MJia0RE5DUYVItQ1wqVCVYAJyIi8v+gOtWW+h0XZUJQkKGu9oyIiHwQg+oqtNRyXFelr7MiIiIiH+NC9e9T7bSY+k1ERBVjUF2FllqOB1f9YEtEREQ+RHK6XehTfaqdFouUERFRxRhUOwbVUv27kgrn+sGV6d9EREQ+yFwAWC0up3/ry76IiIjKw6Da8aBqLQHMhS6uqWb6NxERkc9xXOoVElF5j2qmfxMRUSUYVJ9+prqSddV6+rdUBS2xVN63m4iIiLyIfpyXgDrI6MKaas5UExFRxRhUCzmo6meri7IrfKhUATUYoALq47b+lUREROQ/lb8dC5IyqCYiosowqK5iBfBgY5C9XyVTwImIiPwzqLYXKoth+jcREVWMQXU12mrp66tYrIyIiMjH2Ct/l99Oy2KxIo3Vv4mIyEUMqnWmaO2ysOL0b6de1WyrRURE5Hcz1SfyimC21U2Ji2JQTUREFWNQXY2Z6lNttZj+TURE5G9BtZ6JFhtpgimYH5WIiKhiPFJUJ6i2t9XiTDUREZFPpn+70E6Lqd9EROQKBtWlgmrbwdaFtlp6uw0iIiLytZnq8tdUp2ZpmWjxDKqJiMgFDKp1odFVCKqZ/k1EROTv6d/6SXQiIqKKMKjWMf2biIgogKp/lx9U2yt/2473REREFWFQXa1CZadaalmtWnVQIiIi8pP0b1smGtdUExGRKxhU6/SDqwsttfQ1VkVmC7LyzbW9Z0RERFSX6d+2milM/yYiIlcwqD49qHZhpjosxIiYsGB1neuqiYiI/HRNNdO/iYjIBQyqq5H+LRJiTqWAExERka+tqS47/VuWdTH9m4iIqoJBtS40yuXq34IVwImIiPxvpjq70IyCYou6zvRvIiJyBYPqUunfVQyq2auaiIjIb4Jq/bgeHRqMcJOxLveMiIh8FINqHdO/iYiIEOjVv/UMtHiupyYiIhcxqC5V/buq6d8MqomIiPylT7W9RzXXUxMRkYsYVFdzplpvq5WaxTXVRERE/pb+zfXURETkKgbVZa2ptlorfbh+sNXPaBMREZGXKzEDJYUVB9Ws/E1ERFXEoFpnP7hageK8Sh+u965k+jcREZGPKHbIRit3TTV7VBMRUdUwqNaFRAAwuJwCrp/Bzik0I6/IXNt7R0RERDWlH9+DQoBgU5kPYfo3ERFVFYNqXVCQw7rqyouVRUmrjRCt1QbbahEREfn+emrB9G8iIqoqBtXVLFZmMBiYAk5EROSTlb/LTv0WTP8mIqKqYlDtlrZarABORETk6zPVBcUlyC7QlnTFM/2biIhcxKC6Bm219PVWTP8mIiLypaBa6qiUph/PQ4ODEBMWXJd7RkREPoxBdXlttarSq5rp30RERD6f/m1fTx0TqpZ5ERERuYJBtaPQqgXVp9ZUM/2biIjI19O/7eupmfpNRERVwKDaDenfaZypJiIi8v2gOouVv4mIqOoYVDuqQkstp0JlXFNNRETkQ+nflc1UM6gmIiLXMah2ZIquWvVvpn8TERH54Ex1VCXttJj+TURErmNQ7Yb07xN5xSgyW2pzz4iIiKiO1lTrhUiJiIhqJahevHgxxowZg0aNGqnKmD///HOFj1+0aJF63OnbsWPH4OtBdYOIEIQYteqgaTlMASciIvJqXFNNRETeEFTn5uaie/fumDZtWpWet337dhw9etS+JSQkwHtbamW79HA5ORAfpa+rZgo4ERGRL7fU0guPsvo3ERFVRXCVHg3g/PPPV1tVSRBdv359+EZLLddmqkV8TBiOZBawVzUREZEPz1QXl1iQkVvkVDOFiIioVoLq6urRowcKCwvRpUsXPPnkkxg0aFC5j5XHyabLyspSl8XFxWqrCf35Zb2OwRimBsRSmIMSF79PfGSIujx6Mq/G++YJFY1HoOKYOON4OON4lBaIYxJI7zVQgup02zKu4CADYiNMdb1nRETkw2o9qE5OTsb06dPRp08fFSh/+OGHGDp0KP755x/06tWrzOdMnToVTz31VKn7582bh4iICLfs1/z580vdF5+1GQMBZKcfwaLZs116nfwTkkEfhBVrNqNB+kb4qrLGI9BxTJxxPJxxPAJ7TPLy8jy9C+Tmllp6e8y4qFAEBWn1UoiIiLwiqG7fvr3adAMHDsTu3bvx2muv4bPPPivzOZMnT8akSZOcZqqbNm2KESNGICYmpsazC/LBb/jw4QgJ0WaZdYZDccDulxETZsSoUaNcer3d/9uNZSm7US+pKUaN6gxfU9F4BCqOiTOOhzOOR2mBOCZ6BhX5T0utU+20mPpNRERemv7tqF+/fli6dGm5Xw8NDVXb6eTDmrs+sJX5WuH11IWhKNfl75NcX5s5T88t9ukPk+4cW3/BMXHG8XDG8QjsMQmU9xlI6d+p2az8TUREPtSnet26dSot3NdbajkefPWDMREREflgUG1L/45n5W8iIqrtmeqcnBzs2rXLfnvv3r0qSI6NjUWzZs1U6vbhw4fx6aefqq+//vrraNmyJTp37oyCggK1pnrhwoVqfbTXCY3WLotzAYsFCKr8nIPedkM/GBMREZEXslorTP9OsxUq40w1ERHVelC9atUqnH322fbb+trn8ePHY+bMmaoH9YEDB+xfLyoqwv33368CbSky1q1bN/z5559Or+E1HM9cS2CtB9kV0NdeSdXQEosVRhY3ISIi8j7F+RJZVzpTzTXVRERU60G1VO62ytneckhg7eihhx5Sm08IDgMMQYDVop3NdiGobhhpgsEAWKxARm6hfeaaiIiIvIh9aZcBCA4v9eU0+5pqHseJiMgH1lR7LYmOTbZAutDWdqMSwcYgNIy0ratmCjgREZF3t9MKiShzeZe9+jfTv4mIqIoYVJdbrMy1oNrxAJxmOyATERGR7xQps1is9mM407+JiKiqGFS7owK47QDMCuBERES+F1SfyCuCWdZxqWVdDKqJiKhqGFSfLjSq2jPVTP8mIiLyUvpxvYzK33rqd2ykCaZgfjQiIqKq4ZHjdKbqBNW2tlpM/yYiIvK9HtVcT01ERDXAoPp0TP8mIiIKrKA6Szt+xzOoJiKiamBQfTr9YOti9W+n9G/OVBMREXl5+ndFM9Vsp0VERFXHoLrc9G/XZ6rj9fRvrqkmIiLy8pnq0muqWfmbiIhqgkG1W9ZUn2qpZbVq1UOJiIjIV9ZUa+nfXFNNRETVwaDaDX2q9TVYRSUWZOYX19aeERERUa2sqWb6NxERVR+D6nJbarme/h0WYkRMWLC6znXVREREvtlSi+nfRERUHQyq3TBTLRJiuK6aiIjI12aqZdkW07+JiKgmGFS7oVCZcwVwttUiIiLylaA6u9CMgmKLus70byIiqg4G1eUF1VVoqSXYVouIiMj3WmrpGWbRocEINxk9sWdEROTjGFSXm/5dxZlqpn8TERH5XEstPcMsnuupiYiomhhUu6GlllNbrRwG1URERL6S/m3vUc311EREVE0Mqsut/l21oFpvq5WaxTXVREREvhJUs50WERHVFINqd6V/2w7G+hlvIiIi8iLFFad/c6aaiIiqi0H16fSDrbkAKDG7/DS9tyULlREREfnQTDV7VBMRUQ0xqD6d48G2Cing+hnunEIz8opcD8aJiIi80bRp09CiRQuEhYWhf//+WLlypUvP+/rrr2EwGHDxxRfDa5iLgJIi7bopwulLTP8mIqKaYlB9uuBQICikyingUdKKI0RrxcEK4ERE5Mu++eYbTJo0CU888QTWrFmD7t27Y+TIkUhNTa3wefv27cMDDzyAwYMHwytTv0XI6TPVTP8mIqKaYVDtpnXVclaeKeBEROQPXn31Vdxyyy244YYb0KlTJ0yfPh0RERGYMWNGuc8pKSnBtddei6eeegqtWrWCV9GP50YTEGxy+hLTv4mIqKaCa/wK/rquuuAkUJRdpafJWe79GXn2s95ERES+pqioCKtXr8bkyZPt9wUFBWHYsGFYsWJFuc97+umnkZCQgJtuuglLliyp9PsUFhaqTZeVlaUui4uL1VYT+vPtr5OXCclBs5oiYXZ47YLiEmQXaEu2GoQZa/x9vVmpMQlwHA9nHA9nHI/SAnVMil18vwyqK2yrVb0K4Ez/JiIiX5Wenq5mnRMTE53ul9vbtm0r8zlLly7FRx99hHXr1rn8faZOnapmtU83b948NSvuDvPnz1eX9XP34CwA+eYgzJ892/71dHUOPBghBiuWLJwPgwF+Tx8T0nA8nHE8nHE8Sgu0McnLy3PpcQyq3dhWy96rmunfREQUILKzs3H99dfjgw8+QFxcnMvPk5lwWbftOFPdtGlTjBgxAjExMTWeWZAPfsOHD0dISAgM+5YAO4DwenEYNWqU/XGr958A1v6LxPoRGD3ay9aBu9npYxLoOB7OOB7OOB6lBeqYZNmyqCrDoLqioLrQ9erf4tSaaqZ/ExGRb5LA2Gg0IiUlxel+uZ2UlFTq8bt371YFysaMGWO/z2KxqMvg4GBs374drVu3LvW80NBQtZ1OPqy56wOb/bUs2sluQ2iU02sfzy9Rl4kxYQHzIdGd4+sPOB7OOB7OOB6lBdqYhLj4XlmorCym6Cq31HJM/07jTDUREfkok8mE3r17Y8GCBU5BstweMGBAqcd36NABGzduVKnf+nbhhRfi7LPPVtdl9tlre1RnsfI3ERHVHGeq3Zj+rR+UuaaaiIh8maRljx8/Hn369EG/fv3w+uuvIzc3V1UDF+PGjUPjxo3VumjpY92lSxen59evX19dnn6/x+gnyaUQaVmVvxlUExFRDTCodmdQzfRvIiLyA2PHjkVaWhqmTJmCY8eOoUePHpg7d669eNmBAwdURXCfUd5Mtb2dlpZpRkREVB0Mqius/l3VllraQflEXjGKzBaYgn3oAwcREZGDiRMnqq0sixYtqvC5M2fOhC8F1XqhUSIioupg1FcWPT2sijPVDSJCEGLU+nGk5TAFnIiIyKvTv7mmmoiI3IBBtRvTvw0GA+Kj9HXVTAEnIiLy5plqvbConmlGRERUHQyq3dhSS8Tb1mWxVzUREZH3BtXFJRZk5BY51UQhIiKqDgbVbmyp5VQBnEE1ERGRl6V/nwqq023LtIKDDIiNMHlqz4iIyA8wqHZj+rdjUJ3G9G8iIiIvm6k+taZab38ZFxWKoCCtHgoREVF1MKiuMKiuzkw107+JiIi8Pf37VDstpn4TEVHNMKiusKVWNWaq7b2qGVQTERF5b1DNyt9EROQeDKorbKlVkzXVTP8mIiLy9vTveFb+JiKiug6qFy9ejDFjxqBRo0aqhdTPP/9c6XMWLVqEXr16ITQ0FG3atMHMmTPhr9W/7enftoM1EREReUlQHRJROv2bM9VERFTXQXVubi66d++OadOmufT4vXv3YvTo0Tj77LOxbt063Hvvvbj55pvxxx9/wGvpZ7ItxYBZa7dR1fRvqSpaYrHWxt4RERFRDdO/0/T0b66pJiKiGgqu6hPOP/98tblq+vTpaNmyJV555RV1u2PHjli6dClee+01jBw5El7J4aCrUsCDY11+asNIEwwGQOLpjNxC+8w1EREReYDFAhSXkf5tn6nmcZqIiOo4qK6qFStWYNiwYU73STAtM9blKSwsVJsuKytLXRYXF6utJvTnV/Y6wcZQGEoKUZx3Egix9a2uQmCdnlOEI8dz0SDMCG/m6ngEEo6JM46HM45HaYE4JoH0Xn1ecd6p646FymzLtJj+TUREXh9UHzt2DImJiU73yW0JlPPz8xEeHl7qOVOnTsVTTz1V6v558+YhIuLUeqiamD9/foVfP89gQigKseTPOcgOb1Kl1w61SCBtwOz/LcP+Br6RAl7ZeAQijokzjoczjkdgj0lenkOgRt7N3snDAIRonzksFqtapiWY/k1ERF4fVFfH5MmTMWnSJPttCcCbNm2KESNGICYmpsazC/LBb/jw4QgJCSn3ccF7GgCZ2RhyRm9YG/eu0vf4MX0NDu9MR4sOXTGqd9UC8rrm6ngEEo6JM46HM45HaYE4JnoGFfkAvZOHpH7L+iwAx/OKYLZY1c24KAbVRETk5UF1UlISUlJSnO6T2xIclzVLLaRKuGynkw9r7vrAVulr2XpVB1sK5MFVeu3Eetr6rIxcs898wHTn2PoLjokzjoczjkdgj0mgvE+/7VFtS/2OjTAhxMjuokREVDO1fiQZMGAAFixY4HSfzGjI/V5NL2ZSk7ZatiIoRERE5EVBta3ydzzXUxMRkSeC6pycHNUaSza9ZZZcP3DggD11e9y4cfbH33777dizZw8eeughbNu2De+88w6+/fZb3HffffBq+sHXvhbLdfr6LP2gTURERN4UVOvrqVn5m4iIPBBUr1q1Cj179lSbkLXPcn3KlCnq9tGjR+0BtpB2WrNmzVKz09LfWlprffjhh97bTqtUUF2dmWo9qOZMNRERkdesqbZJs7fT4kw1ERF5YE310KFDYbWWX9F65syZZT5n7dq18Cn6wbcaQXW8nv5tW7NFRERE3rSmWsskY1BNRETuwOoclRQqq1b6t+0gLWfCKzoBQURERB5M/2ZQTUREbsCguhbWVOuFT4pKLMjML3b3nhEREVEN0r+5ppqIiNyJQXWl1b+zq/zUsBAj6oVr7Va4rpqIiMg7q39zppqIiNyBQXWla6qrPlPtVKyM66qJiIi8JqiWZVn6sVlvgUlERFQTDKprIf1bsK0WERGRN6V/a8f1rAIzCs0Wp2M1ERFRTTCoroWWWo5nv5n+TURE5A0z1VoGWprtZHd0WLBarkVERFRTDKrLExpdw6Ca6d9ERETelv59KvWbs9REROQeDKprKf1brwDO9G8iIiIvCqrt7bS4npqIiNyDQXVlQXVhNWeqbW06mP5NRETkQcWnB9W2yt9cT01ERG7CoLo8pmi3VP9OY1BNRETkOUz/JiKiWsag2pVCZVZrDdZUM/2biIjIY5j+TUREtYxBdWVBtbUEMBdWO/07t6gEuYVmd+8dERERVamlllb9m+nfRETkbgyqKwuqq1kBPCo0GBEmrVUH11UTERF5gGSalTNTrRcUJSIiqikG1eUJMgIhEW5qq8UUcCIiojpXUgRYzE5BdZp9TTXTv4mIyD0YVNdiWy39gM2ZaiIiIg9wPH6HRCK/qATZtiVZTP8mIiJ3YVBdi2214m0HbAbVREREHmynFRwGGIPt66nDQoIQHRrs2X0jIiK/waDapbZaNUz/th3EiYiIyDsqfxsMBk/uGRER+REG1XWQ/q2v3yIiIqK6Y2CPaiIiqgMMql3tVV2jmWoG1URERHXOHlSznRYREdUeBtUVCY2q2Uy1fU0107+JiIg816PaVvnbIf2biIjIXRhUV8R2Zru6M9V6D0zOVBMREXmwUBl7VBMRUS1iUF2L1b/1M+En84pRaC5x554RERGRy2uq9fRvBtVEROR+DKpdmqmuXvp3g4gQhBgNTilnREREVEdKFSqzralmUE1ERG7EoLoWC5VJu474KKaAExEReUNQzTXVRERUGxhU1+KaahEfE+bUxoOIiIjqfk11cYkFGblF6iarfxMRkTsxqK7FPtWOKWZprABORERUtxzWVKfnaCe3g4MMiI0weXa/iIjIrzCorsWWWoK9qomIiDxdqCzSnjEWFxWKoCCt3gkREZE7MKiu5fRvfd0W07+JiIjqmB5Uh0TYT24z9ZuIiNyNQXUtttRyPHinMv2biIiobhXnaZemKPtxmJW/iYjI3RhU12JLLcH0byIiIg8pI/07npW/iYjIzRhU13qhMlv6N4NqIiKiOmVwqP5tT//mTDUREbkZg2pX11RbrTVK/87IKUSJpXqvQURERDWr/q134eCaaiIicjcG1a5U/4b11LqsKmoYaYLBAEg8LYE1EREReSD92z5TzfRvIiJyLwbVFQkOl+SxGqWABxuD0DCS66qJiGpTWnYhPvt7P+ZvSfH0rpCXr6lm+jcREblbsNtf0Z8EBWnrqiX9uzAbiEqo1svIATw9p9BWebSe23eTiChQA+m5m49h9oaj+GdvhsoI6t8yFsM7JXp618gbWC0wmPPVVUtIpDoOC6Z/ExGRuzGodmVdtQTVNSlWFhOKLUfZq5qIqKYkMJq76RhmOQTSuu5N6qmA2mq1wiDrbiigBVtOHXOPm0NgtsjvBRAXxaCaiIjci0F1nVQAZ/o3EVF1ST0KmZGWQPrvPc6BdLcm9TC6azJGdU1G09gIT+4meZlgi1aYDAYjUm2H8NgIE0KMXPlGRETuxaDa5aA6xw1ttWwHeCIicimQnr3xKFbsLh1ISxAtwTQDaSqPscR2zDVFIdWW+h3P9dREROQtQfW0adPw0ksv4dixY+jevTveeust9OvXr8zHzpw5EzfccIPTfaGhoSgoKPC9tlrVpK/fYvo3EVHFgfQfm1Mwa+ORUoF018b1MLpbMkZ1SUazhgykqQrp346Vv2NY+ZuIiLwgqP7mm28wadIkTJ8+Hf3798frr7+OkSNHYvv27UhIKLuQV0xMjPq6zqfWuulttZj+TUQ2Zoun98D/Amk1I70nAyUOkbQE0vqMNANpqnb6tylSFbUTrPxNREReEVS/+uqruOWWW+yzzxJcz5o1CzNmzMAjjzxS5nMkiE5KSoJPp38XVn+mOt6W/q0f1InINxWaS3Drp2vw714jGnc9gTPaVK8jQKA7nluEP2xrpE8PpLs0jsHoro0wqmsSmje0/f9LVA3GEoeZ6iwtwGZQTUREHg+qi4qKsHr1akyePNl+X1BQEIYNG4YVK1aU+7ycnBw0b94cFosFvXr1wnPPPYfOnTuX+/jCwkK16bKystRlcXGx2mpCf76rr2MMjlDNvEsKsmCp5veODTfa11TLGHrTTH1VxyMQcEyccTw0FosV93+/EX/tTFf96+/8ah1+umMAkusxndSV3xEJpOdvTcWcTSn4e+9xp0C6U3I0RnVJwnldEtHcYY20N//OefO+0ekz1VGn0r8ZVBMRkaeD6vT0dJSUlCAx0bkHqNzetm1bmc9p3769msXu1q0bMjMz8fLLL2PgwIHYvHkzmjRpUuZzpk6diqeeeqrU/fPmzUNEhHtSAOfPn+/S47ocSUNrALu3bsDWzNnV+l7FKlU0GMUlVnz/6xxEhsDruDoegYRj4izQx+P3A0GYfzgIQQYrYk1Aem4xrnn3L9zTuQQm7bxZwDv9dyS3GNhw3IC1GQbszDTAglMnFJtEWtGjoQU9Yq2IDz8B5JzA5r+3YjN8Q15enqd3gaqQ/q3XNOGaaiIi8snq3wMGDFCbTgLqjh074r333sMzzzxT5nNkJlzWbTvOVDdt2hQjRoxQ67NrOrsgH/yGDx+OkJDKo9ugReuAtHlo3TQJLUeOqvb3fWbDQmTmm9H9jMFolxgNb1HV8QgEHBNnHA/g21WHMH/FFnX9mTEdUXhwE97aHo5DucVYlN8Er13R1asyUDz5O5JTbMWfW1Mxe1MKVuxxnpHumCQz0ok4v4ukdvv2Gmk9g4q8V7Bj+ret+wZnqomIyONBdVxcHIxGI1JSUpzul9uurpmWD+U9e/bErl27yn2MVAeXraznuutDvcuvFaYFwEZzHow1+N7SViszPwfH80u8MjBx59j6C46Js0Adj8U70jDlt63q+t3ntsWVfZthdtomvHVVd0yYuRqzNh5Dp0b1cOfZbRCoTuQVYUWKAd9/uUEF0mbHQDo5BhdI1e6uyWgZ5z9rpAPxb8HXGG0z1VbHmWpbjRMiIiJ3kuXCLjOZTOjduzcWLFhgv0/WScttx9noikj6+MaNG5GcnAyfEBpd45Zagm21iHzP1qNZ+M8Xa9Rs66U9G+O+YW3tX+vfMhZPXqjVhnh53nb8ucX5ZGOg+HbVQQx68S98vceIJbsyVEAtgfQDI9ph4f1nYc49g9UJB38KqMm3WmoVBYWj0FayXz8WExEReTT9W9Kyx48fjz59+qje1NJSKzc3114NfNy4cWjcuLFaFy2efvppnHHGGWjTpg1Onjyp+lvv378fN998M3yq+nf+CeDkAaAwGyjI0i4Ls4CCzFPXHb9WUgS0Pw/ocS0QEm4/O862WkS+4VhmAW6c+S9yCs04o1Usnr+sW6kU7+vOaK4C7y/+OYB7v1mHn/4zEG29aHlHbZPq3Q//sAFWK5AcYcVVA9piTI/GaBVva0VI5AVrqnOtWiAdHRaMsBAWQCAiIi8IqseOHYu0tDRMmTIFx44dQ48ePTB37lx78bIDBw6oiuC6EydOqBZc8tgGDRqome7ly5ejU6dO8Kmgeu9i4PWuVXvurvnAoueB/rejafgQdRfbahF5PwmkJaA+mlmA1vGReO+6PjAFl53Y88SYztiZmoOVe4/j5k9X4Zc7B6F+hAn+7q8dabj3m7UqoB7bpwkGBO/D6KGtmBZNXsNYogXV2RYtqOZ6aiKqTZKN68+dIeS9BQcHo6CgQL1XfxESEqKWN3ukUNnEiRPVVpZFixY53X7ttdfU5rMa9wbC6mkz0sZQLR08LEa7DJXLmNNu274us9UrPwQyDwALn8FEYyQig4fiwIkJ0kDG0++KiMphLrFg4pdrsOVoFuKiTJh5Qz/Uiyg/UJRg+91re+HCt5dhf0YeJn65FjNv6ItgY5VW1/iU1fuP4/bPVquOBqO7JeOpMR3xx9x9nt4tojLTvzNLtJNcXE9NRLXBarWqyUPJyPX39yk1tA4ePOh3xVnr16+v3ltN3letV//2efWaAA/uBqwWILiKZ7nP+A+w+Sdg6WswpW7BbcGzULxnHvDr1cDAe4C4wC1sROStB4wnft2MRdvTEBYShA/H90VTh77J5WkYFYoPxvXBZe8ux9Jd6Xhu9jZMGePDJ89KzEBOCpB1WNuMJiChI1C/Bbam5OCGj/9FfnEJzmoXj9eu7AGD1X/OWJP/MNqC6uPF2kkxrqcmotqgB9QJCQmq9a+/BZyOdbRycnIQFRXllJXs65/78vLykJqaqm7XpOYXg2pXGEOq/7xuVwJdr8C2Jd8j68+X0C9oO7DmU2DNZ0DHMcCZ92qz4XWhuAA4+A8QFAw07Q8Y+eMncvT+4j1qfbQcD9+4qid6NK3v8nM7NYrBq1d2xx1frMGMZXvRITkaV/ZpCu8MmI8BmbaAOevIqeBZrsv98nU5kXgaS3AYrObGmFLSGHlxbTF2wAiYco+gODzBI2+Fate0adNUHRT5wNi9e3e89dZbqpZKWT744AN8+umn2LRpk7otS72ee+65ch9fl2uqM4psQTXTv4nIzSQNWg+oGzZsCH8mQXVRURHCwsL8JqgW4eHh6lICa/k5VjcVnFFVXTAYYOp4Pq6cHYEzTTvxeYe/gR1zgK2/alvLs7TgutXZ6rFuI4sd07YDuxcAuxYA+5cBZu1DBsLqA+3Og6HteTBKUTUid/7eSXAW3gAwRfhU0a2pc7ap64+P7oSRnV1rE+jo/K7JuOfctnhjwU489tMmtI6PQu/mDeC5n8Nh4NhG4NgmIEUuNwIn9pUZMJciJ9+iGwExyUBxPqxp2xFkLkAn7EYn424gZzHwzUfqocGh0RgcnAijdT6Q1Fmb1Zb/Y8resfL311wImPO1E4DFedr/V8X5tssC29fyT91nKQGiEoDoJCA62flSr4dB1fLNN9+owqTTp09H//79VVHSkSNHYvv27epDR1lLv66++moMHDhQfeB64YUXMGLECGzevFkVL/Vkn+rUQj2oZvo3EbmXvoZaZqjJd+k/P/l5Mqj2cgkx2sF8aVFb5F42EZGZO4FlbwAbvwP2/qVtiV2AJn2Ahm2Bhm2AuLZA/eZVm1HOOw7sWaQF0rv/p32odiQfOOWDa/5xYMPXCN7wNc43hMCQ9z3Q8QKg/fnah1SiqrBYgMOrgG2/A9tmARm7gKAQoHEvoPkgoMUgLTtCb1HnhWuE7/t2nbo+YWAL3Hhmy2q/1j3ntEbW/nX4c3cObv/0X/x692Ak19POgtYa+ZtO22YLnjfZAumNQEE567vkZyPBckxjIKaR7dJ2vZ7temQCYDsTfSK3CFdNX4qi9D0YFJOGyb2tiMzcAaRuAzJ2wlCYjVipI7FuF7yG1LhQQbYeaOtbEtBsABCtFdeksr366quqyKje2UOC61mzZmHGjBl45JFHSj3+iy++cLr94Ycf4ocfflAtN6UriCdnqlMKtA9ITP8motrirynfgcLghp8fg+o6EhUajAiTEXlFJaqtVkuZyblkOnD2/wErpgFrPtE+DMt2+mxRg5ZagN2wtXPAHRmvzdRIMCMz0RJIH17jPBMUHAY0Hwi0Phdocy4Q30F7jqSBb5sF67ZZMJ7cB+yap22/GbTgp8MooMMF2vcMdHKiQn4OUoCOnAO5vUu0QHr7bG0Nrp0BsBRrv2eyLX0VMBiB5O5agN38TKDZGUC46+nVtWVvei5u/mQViswWDOuYiMcvqMZa6KI87WTW9tkI2vEHnshNxROhQI45DIfeao74zn0RnNxFm8FN6AxExVcvbVtOkmUe1Nr7nTwIHN+tBdLp2wGLufRzZMzj2wNJXbWTdnIp/wdEJdoDZlcqoU/4eCW2p+UjKaYlbrvtGkQ6rjM3F6E4dTvWzfsSvRqHw5ixXQvwZTa5qqRuRXA4EBIGhERo/3/Jdf0+dWnb5GuGICA3Dcg+CmQf0y6zjgLFubY2h1lA+o7S3+fqb7SWh1QmSe9bvXo1Jk+ebL9PUv2GDRuGFStWuPQaskZNzvjHxsaW+5jCwkK16bKystSlPK+mFXTVbINtTfWRPO13PTY82K8r81ZGf++BPAaOOB7OOB7VGw/5uqzLldRo2fyZvE/90t/eq8ViUe+rrJlqV/8mGFTXIVnPtS8jD6lZBWgZZ0tNrN8UOP95YMiDwK4/tQ+AMsuntt1aumPGTm07XWg9LYCWD46O4jtqAXTrc7SAWj6AOpKZ7xaDUNJsIF7HdVi/chEujt6GM4r/QaO8bcDBv7Vt/hTtA3j7UdqMY5TM+CRqH8irWrTNF5iL1PgbjqxHp8O/w/jVx0DqllPBYngs0KAF0KC57bKFlkkgl1LQrrpr732J9GHfOU+bjd45HyjKdp4ZbDsC6DAaaDMMyEsH9i8H9i0D9i/VAsEja7Rt+Vta4J3URQuw1Uz2GUBELBBUd31kj+cW4YaPV+JEXjG6NamHN6/uAWOQi2crJYDbswDYPkfLNNGXVoiQSFhLihBlKUAH83ZgvWwOz5UTYnqALZeJnbUTWPknTgXM6vLAqSBaUuorKggmXQoSu2qBc5JDAF2Dv9WC4hLc+ukqrD+UiQYRIfj85n6lC7cFm9T3OdLgDPQYOgpGb2ipJbPmepBd1mX9Zp7eQ6+Wnp6u1gnqrTJ1cnvbNm2JRGUefvhhNGrUSAXi5Zk6dSqeeuqpUvfPmzfPLamUo2wttfZnaR8Et679G8dd232/Nn/+fE/vglfheDjjeFRtPKTFlFSNlgJeckIyEGRnO3z2s+nWrRvuuOMOtfki+dnl5+dj8eLFMJvNpU4Su4JBdR2S9VwqqC6rV3VkQ6D7WOf75CyQzEzpQXb6Ttv1ndqH7sJM7XGydlXWY0sgLZeSvlmJvCIz7vl6HeZvkYCxORbnNQcwEsnIwDDjaowIWoUzgrYiRGacZDuNNbwBDJJKKQG2pFPql+q6bAlaxWChUioMDuvFy7pu0NZ5yjpKteUDRbnadf3S6T65navNukswIes3ZdZTXbfd1q/L/WpWyyFYyknV0mNTNtu2Tdr6c0ux+qNoK4/RCgGeIinzsklQWNaMoIy7HmRL4C3ps/KzOX2TkxzVSTOR9yonUCSwVbNw2VogZ5+9i3C4tM3qVbWQhPzOyTpEeV05ySCX+dlonr4Qxq8+AfYt1magdfKz1rMaWgzWAiydzOzHtgJ6Xqfdlt9ZCbIlwJZAW82y2tKU/3nXeSzld0deS9rYSVAoJyzUddt9+tflvUY01H7fZLxlBlgCVv26/B6UM9YSMN7y6Sr1N9m4fjg+HN8HEaYK/kuUM7THNiBo6yycte0bhKw9rYWUBGrtztdmQJufqVKJ1q1bjRk/zUIbHMAFSZloZdkPHN+rza7ulW1x1X4+krYtJ+LqNdW+n/yeSWAuQbTc58b0M2ktdvdXa7F8dwYiTUZ8cmM/tEnwzvT9UlSLw2gto4fq3PPPP4+vv/5arbOW9dXlkZlwWbftOFPdtGlTtRY7JqZmmUHFRUUIXqsF1cdLtH24fPRwRId5wUkfD5HZFgkQhg8fzn7yHI9SOB7VGw/p2SwtpqQidkX/33mjc845RxWhdLX1sczkSkAdHR1dKl3633//RWRkpM+uLZefoxQsGzJkSKmfo55FVRkG1XUo3raeq8yguiwSEMkHaNlan+38NSnac3yPlvIps1xVmN07llmAmz75F5uPZKkeuxc0KUb3rl1w6GQB9mUk4p+M5vg24zyEFmZjaNA6nGNci2aGVCQYTiIeJxFqMMMgM2qyyUyuL5AgTA+2ZZ2pBDVlCY2BJaET9uVHoVnf8xHcuIc22ycB/8n9wAnZ9tmu77NdP6AFn/rM4r4llexLqDYj6xRs1wdM0dqJAsegWb8ul/K1qlLps44BtwT0QacCZilS5xhAOwbMNnIo6eF4hyxBkPX3Ekg36uV64K5+l8eeOnkkaboH9JnsZadO3shsrGRoyFZTEoRKkB2lB9oJ6vfAajDir20ZOCstD+eGhWBst5ZouG6dluZv34zaJuN1ZB2wY646ySV/aZK0boUBBqmB0O48rRZBQqdSQW2P3megb1ESHv9lM147DHw0vg/OaRWlncCRv53UrdpJHbmUittyIkSNU7NTgbPj9SqkbdeExWLFwz9sxLwtKer/iA/G90G3Jp5P1ae6ERcXp9LfUlIcl3RA3ZYZmYq8/PLLKqj+888/1cxFRUJDQ9V2OvkAW+MP9cX5MNiWQuUhTLXIaxAVznWP7hpfP8LxcMbxqNp4SFaP/L8iS2R8sSK2vu/lBdHy/mQ2Xugp32U9J/G0zCZfI+9H3ldZP29X/x4YVNchvZ1HarZDmmh1yUxkYtXXfm46nKkC6pSsQjSMNOHda3rg6KblGNWvqdMvjXyoTskuwL70c7E/IxfzMvLU5b70XJw8noLo4gwVZCfihLpMMJxAvLrU7osPykIwbP/RqPBD5qKt2sS0WpNh1Wb+Tq8ErII/22bSLyMdbkfaLiVAjNQCjILMU1v+SefbskmQJsGjBNL2YNqgpdvKOlO1nZrtKzGbsXH2bDTtNUr+kk7tm0qr7Vp6UOU/GUkRtwfa+7XreRnaiQfHTU6CyEywSkM9imqRQFlSrWUmWAJ0FRTbqiXrVZF1+tfke1eZQX0va7AJJ4LiUK//NTB2uhCIbwe3kEJZXS7TNmGv6lyo/bxUwF9omzkvKvs+OdGQm65lHug/X3U9XcvkkJME2Ue0zfmdYaRs+v+AK13c55AIWFoOxfqCZHS55H6ENKg8K+S6M5pjy9FsfLXyAO75ah1+unMg2shyCtkcSRaG/J57+EO/HESfmbUFP6w5pFLhp13TCwNbx3l0n6humUwm1RJLioxdfPHF9g9TcnvixInlPu/FF1/Es88+iz/++AN9+vSpwz0ug/w92eQjFE2iwxhQExHZTJgwAX/99Zfa3njjDXXfxx9/rIpTzp49G4899hg2btyoluNIBpFkFf3999/Izc1Fx44d1fIdx+U9LVq0wL333qs2If/fSqtFKXApxwTpAvHKK6/gwgsvrHTfJJC/9dZbsXDhQtXSsVmzZvjPf/6De+65x+lxUjhTXnPXrl2qfsdll12Gt99+W31N2pzJMqSff/4ZmZmZaNOmjTrhe8EFF6C2MKiuQ3o7j7QsF2eq3Wze5mMq5Tu/uARtE6IwY0JfJEWH4OhptdFEUJBBVSyWbUDrhqU+dKflFGJ/Rp4KsuVydUau/XZ2YRkFkxzER4eiRcMING8Y6XApWziiwx3Sh91BAveiHIeA+6QWkMu6c3e1e5LAXlVSTtaKb1W2L6cH2vomM9NyokCCZT1oVmms+vV62m3HFOuySJDv2HpIbXmnLmXWXaVU21Kr9U3dlrRxSa0O02ZrDQaYi4uxZPZsjBpYy+tl9Zl0d5FsDhVo24JsFWynYvPeQ1i6IwXBsOCstrFo0zBMO9kh6fVyAkZd1zeLFpjLTLHMSLccghIYcWD2bHRxsUq+HFieurAzdqfmYOW+46oo2i93nol6EaeNpZe0gHpzwS58vExLbX/p8m4Y3sm3zz5T9cgHqPHjx6vgWHpNS0st+TClVwOXit7yIUk+WAlpoTVlyhR8+eWX6sOVfBASkhIpW52zZfaYjeGwIIg9qomozsjnZPms7QnhIUaXTiBKIL1jxw506dIFTz/9tLpPWiAK6fAgWUetWrVCgwYNVHr7qFGj8Mwzz6i0+J9++gljxoxRLRYl4C3PU089pU62vvTSS3jrrbdw7bXXYv/+/RUWsNRP4jZp0gTfffed6v29fPlyFWQnJyfjyiuvVI9599131XFKAuXzzz9fBc7Lli2zP1/uk1T1zz//HK1bt8aWLVuq3SrLVQyqPTJTXVjnf9wfLtmL5+ZsVXHd4LZxmHZtL8SEhVSryqP8scoJAtn6togt9b2k6NM+FWTLzLZthts20y1fS8suVNu/+0rPnnZpHIMz28RjSNs49G7RAKHBNfwDkP9Y9PWVUkzMkxz3pTYLJUmQLwGalwRpHiPZHPryCZv/bU/FzXNWocRixX3D2qHNsGqsua3G34ykUL9zXS9c9PYy9bcw8as1+HhCXwQbvStVbOayvXjtT61a9hNjOuHSXh7+myGPGTt2LNLS0lSgLAFyjx49MHfuXHuK34EDB5zS/+QDjhR6ufzyy51e54knnsCTTz7psZnq4iDtRB3baRFRXZGAutOUPzzyvbc8PbLi+jA29erVU1lJsgZaX9ajF6KUIFvWkuskCJa11xKsyvpi+brMAP/6668VZi9NmDABV199tbr+3HPP4c0338TKlStx3nkVd9+QzFnHIpYtW7ZUnSe+/fZbe1D93//+F/fff7/T7HXfvn3VpSw/ku+zdetWtGunZVfKCYLaxqC6DukHdbekf7uouMSCKb9sVqmn4pr+zdSsWUgtfZiXgDs20qS2Xs0alPp6Zl4x9h+3Bdnpp4JtuUzPKcSmw1lqm/7XbrUGrn/LhuokwOC28WiXGMX0Paq2zUcyMfGLNSqgvqxXE9x9bps6/f5xUaF4f1xvXP7uCizZmY7n52zDY9Vp31VLflxzCE/+ptVIuHdYW9wwqPq9usk/yIel8j4wSREyR/v2nVa4z8MMtqC6QA+qbZliRERUsdOX70hlczk5KqncR44cUenZUilbTq5WpJtDXQ0pYiYFKFNTT68CXLZp06ap9G75HvK95KStnNwV8hqyH+eee26Zz123bp2a6dYD6rrCoLoO6Qf1upqpzswvxp1frMHSXelqkvT/RnXETWe29GhgKimv3SLql1n0SE42LNuVrgIO2WQ2+68daWoDtqqZ/jPbxmFI23gMahOn0siJXHE0Mx83zvwXuUUlGNi6IaZe2tUjfwedG9XDy1d0x51frsGHS/eiQ3IMLu/t+dlg6QLw4Pcb1PUbBrXAPeeyajb5OFtQLUXKBI8XRFSXKdgyY+yp711TEgA7euCBB1QldEnlllnt+Ph4NWNcWQuxkNOWDMrnLlf6W0v3CPmesl56wIABqtq4pJD/888/6utSpbsilX29tjCo9kD698m8YhSaS2qe2lyBAxl5uPGTf7ErNQcRJiPevKonhnn52kg56XBJzyZqkzTy7SnZWLozHYt3pmPl3gx1MuLHNYfVJjomx6g0cQm0JQ09zA3/kZD/yS4oxg0fa8X5pJbAu9f1VunYnjK6WzK2H2uDNxfuwqM/bkSr+MgyszrqyvLd6SrI12fwHx/diRkh5DdBda5VO+5yTTUR1RU5hrqSgu1pkv4ts86VkbXKksp9ySWXqPRvWfpTm9lJy5Ytw8CBA1VxMt3u3bvt1yXIltodUjzz7LPPLnOG/NChQ2rNeF3OVnv/T9yP1I8IgckYhKISi5qFbdKgdnq5rd5/HLd8uhrHc4uQFBOGjyb0UTNkvvYfUoekGLXdPLiV6im8ev8J2yx2mmoHtvWotr23eA9Cg4PQr2WsShWXNdkdk0v30KPKSdX39NxCpGQWqtndlKwCHDmZh6w0A841W5yKofsCWf7wny/WYNuxbDVT9fENfVEv3PNv4t5h7dQ+Scuq2z5bjd8mnomkenWfnrrh0Enc8skqFJktqiDZC5d1VUUKiXyerVBZlsUWVMcw/ZuIyJEEpjL7KwGyFJQsbxa5bdu2+PHHHzF69GhVsFJmrF2Zca4u+X6ffvqpqhou66k/++wz1QdbruskHf32229HQkKCvSiZBON33XUXzjrrLNVvWqqBv/rqq6ryt6wXl7igsvXcNcGgug7JD1M+2B8+ma9mXWsjqP5l3WGVxikfkqXo10fj+yLRDz5MyCy0pHzL9sj5HdT6az1VXGazj2UV2NPGgW1q/aoWYMt67Dh+oJKJG7NFBcmyHc08dSl9y2X8jtnuM1tOa3OmGPHnq0tw45kt1br86DDPB6aVkWyHx3/epH4nJB1KekTX1omsqpLA9dWxPXDpO8uwIyUHt322Ct/cNqBOsy12pWZj/IyVKiV+QKuGeOvqnl5XOI2ougzSaUGWQZm1/6s4U01E5ExSrKXLQ6dOndS6ZWmpVRYJTG+88UaceeaZqmiZVAeXILa23HbbbVi7dq0qmCmxkxQ7k1nrOXPm2B8j+11QUIDXXntNvY+4uDinQpk//PCDul+eKycC9JZatYlBdR2zB9VubqslAcQbC3bi9T93qtsjOiXi9at6+ET6SXVI0HxRj8Zqk/cuae76LPbfe46roPuntYfVJtonRmtBdts4Vfws3ORfqeK5hebTAuV8e6CsX6bnVLz2RScT/PIBVLIcZPa0fngI5m44iJTsQkydsw1vL9yFa89ojhsHtfDqkxXvLNqNr/89CJl4lYCxrHX8nhQVGowPx/XFhdOWYv2hTDzywwa8NrZHnWRYHDyeh+s+XKmq8XdvUg8fjO/D5RPkl+nfJ0u0FoQMqomInElqtFTVdiRp3mXNaEvPaL36txQcO72I5b7T0sHls/nppHe0K0JDQ1WAf3qQr7dwdAy+ZSuLBP9S6Kwu+WfE5cX0A3uaGyuAS2q0fCD/ed0Rdfu2Ia3w8HkdAiaNU4KQtonRapOZVFmvvmb/SSzdlaYC7Y2HM9X6bNmkOJSk4Pdp0UBVFJdAu1NyjNeOld6iTE/Fts8sOwTLslXWG1wn710CZT1gPv16cr0wxEeFOs1YStu1fsZ9KG7UHR8u269OYEh19hlL9+LSXo1x65BWaBXvgT60lWRsvPTHdnX9iTGdvbaeQLOGEXjnml64fsZK9fcrdQJuO6t1rX5PWXpy/Uf/qN8fWWM+84Z+KsAn8stCZdYwBAcZ0CBCC66JiIhqAz9JeaytlntmqjNyCnHrZ6vVemP54PDMxV1wdb9a7IHsA6QA3IDWDdX24EjgRG4Rlu1Ox5Id2kz2kcwCLN+dobYX5gINI00qrVxmsSXIjosIrjDILTRbUFhsUcG7XJeTGuo+cwkK9PvVZflfK3B4jNPX1HNs9xWVID23SKVtuyI6NNgpUJYAOdEWKMsSgOR64WgQEVKtmVCp63Vhr8a4sm9zLNiWqoJq+Z2TmeBvVh3EyE5JuO2sVujpwYJbupV7j+PB77RK1lLtfvzAFvBmA9vEYcoFnfDEr5vx/NxtaJcUjbPbJ9RaR4BxM1aqFnZNGoTjs5v6o0Ekgw3y3zXVuQhTGWLeeuKUiCjQ3H777fj888/L/Np1112H6dOnwxcxqPZUWy03pH/LmsgbZv6Lg8fzER0WjOnX9VbBITmToOGCbo3UJkHxnvRctQ5bAuwVuzOQkVuEX9cfUZto2TACxQVGvLFzmSoq5xgcuxrgultclMkWLIcjqV6oCpC1QFkLmOVrdTHbKB9MpaCVbKv2HVfB9Z9bUzF38zG19W8Zi9uHtsbQdvEeKRS3Oy0Ht362Sv3cRnZOxKOjOsIXjBvQXBXdk5MUd3+5Fj/dOQhtEtw7+59XZFZtxeT7yPKJz2/q75HiaER1oijPPlPN1G8iIu/x9NNPq/XOZZHUcl/FoLqO6Qd36clcExIU3vHFamQXmNEsNgIzJvRBm4RoN+2l/5JAr3V8lNpkBlOqQ689cFIF2JIqLtWQ92bIhzEDkKvNdJRHJj5kHapUHpfZ8bAQ7TI0JAhhtkv1NYfHyKX9OU6Pc3i+eqz2uNhIkwqaPdkCqjx9WsTiwxax2JmSrSqwS8r1P3uPq61DUrSauZYTGSF1VPxKsjakdZa0rOvRtD5eH9sTRh+ZnZLfy6cv6qJOCvy77wRu/XSVCqzdValcTgbd8fkalV0QExaMz27qhxZxzn0oifyJwT5THYp428lsIiLyvISEBLX5GwbVPpj+/dXKA3js502qr2yf5g3w3vW90TCKZ+KrQwI+acUl2/0j2iMzrxir96Vj5b//4swB/REZZnIIgo0IcwiSJd2ebbug1rK/fEV33D+inVpn/eU/B1S7qPu+WY+X/9ihUrCv6te0VovmSSbBzZ+uwoHjeWgaG44Px/fxuWJ0cuJEemhf+NZSlU1x91drMWNC3xqfGJD/J+77dh3+2pGmqqBLWzFZu00UEGuqEWY/7hIREdUW75v+CpT072oE1fLh+LnZWzH5x43q+sU9GuHzm/szoHajehEhal11x/pWlcosa4QlAJFCXI3rh6uxljRrCcYZUDuTlPT/G90Jyx85Fw+ObK9S1qXS/dO/b8HA5xfi1fk71GxybfTWvu+bdSrjQGZ2P57QT6U3+yLZ7/fHSSXuIBUEvzB3W41eT5Y7yAm4WRuOIsRowPTre6N381i37S+RtwfVuUz/JiKiOsCguo7pB3cJLiQwrsp6yNs/X433F+9Rt+8b1k6132EbHPLGExN3nt0GSx8+B89e0gUtGkaolOw3F+zEoBcWYsovm3BApdi7hxT3mrPpmKps/v71vd2+FrmudWlcT838C/l7/2H1oWq/1gtzt6vMFjn/I+nwZ7WLd+OeEvnITDXTv4mIqJYxqK5jMtMp2ZwST7s6ayctk658bwXmb0lRKaJvXNUD9wxry5lS8mpywufa/s2x4P6heOfaXujWpJ6qbP7piv0Y+vL/cNdXa7HpcGaNvsdnK/bZTzS9dEU39G/VEP5A1qJPPLuNuj75p41Yd9C13o6O3l20WxWSE89d0hWjuyW7fT+JvH9NNWeqiYio9jGormOyPlJP13YlBVyCjounLcOmw1mq9dNXt/THRT0a18GeErmH/M6P6pqMX+4chC9v6Y8h7eLVSaXf1h/BBW8tVT2Tl+1KV6nKVbFga4pqQyUeGNHO7/4uJg1vh2EdE1WRMSlcJn3KXSXr2vXU8cnndwj4NnsUeCytzsaf1r5ItdbnmmoiIqp1DKq9uAK4zExfMX0FjmUVqJTWn+8cxPWQ5LMks2Jg6zh8emM/zLr7TFzUo5EKuKXq+rUf/oML316G3zcccWlZxMZDmZj45VoVnF/Zp4lKN/c30r7stbHd0S4xSp2Ak370UpCtMnKy4v9+3qiu3zG0NW47q3Ud7C2Rdyk+52ncWngvdlsbM/2biKgWtGjRAq+//rqnd8NrMKj2ZFBdTq9qmbH7cMke1W83v7hEFc764Y6BaBobUcd7SlQ7Ojeqhzeu6olFDwzF+AHNVWGujYe1QPmcVxbh87/3lxtASvGzGz/5V/1tnNkmDs9e0tVvl0JEh4Xgg3F9UD8iBOsPnsSjP26scEZ/0fZUTPp2HeQh1/RvhodGtq/T/SXyFifyimCBdGiQAoAmT+8OERH5OQbVXlYBXPom/9/Pm/DfWVvtH4ylrY67+tUSeRM5UfTURV1UxfB7zm2rgsf9GXmqYvWZLyzE2wt3qjZnuqyCYtzw8UqkZReifWI03rmuV531wfaU5g0jMe2aXmpW/8e1h/Hhkr1lPm7VvuOqmGFxiRUXdEvGMxd18duTDUSV0Y+vsREmBPv5/xFEROR5PNJ4tFe1c/p3Zn4xbpz5r1oPKZ+FHxvdEc9e3MXvgwai2EgT7hveDssfOQdPjumk2pel5xTh5Xk7MPD5Bfjv71tUxfA7Pl+NHSk5Kttjxg19ERMWGCebBrWJU/8fiKlztqoZaUdbjmThhpn/qkJwQ9vH49Ure9S4vzWRL5MTbyKeRcqIiEp5//330ahRI1gsFqf7L7roItx4443YvXu3up6YmIioqCj07dsXf/75Z7W/36uvvoquXbsiMjISTZs2xX/+8x/k5OQ4PWbZsmUYOnQoIiIi0KBBA4wcORInTpxQX5P9fPHFF9GmTRuEhoaiWbNmePbZZ+FNGK15QHwZ6d8Hj+fhsneXq/Wl4SFGvH99H9w8uBVnmiigRJiCMWFQSyx6cKiqct8hKRq5RSX4cOleDHnpf1i2KwMRJqPK3pDAO5BMGNgCY/s0VevIpXL67jTtYLQ3PRfjZvyD7AIz+jRvgHev7a26BBAFstTsInWZEM3UbyKqY5JqKm39PLG5WPT1iiuuQEZGBv73v//Z7zt+/Djmzp2La6+9VgW8o0aNwoIFC7B27Vqcd955Ksg+ePBgtYYkKCgIb775JjZv3oxPPvkECxcuxEMPPWT/+rp163DuueeiU6dOWLFiBZYuXYoxY8agpERbCjh58mQ8//zzePzxx7FlyxZ8+eWXKuD3JsGe3oHALlSmBdWr9x/HrZ+uRkZuERJjQvHR+L6qVy1RoJLsDKnmfWH3RvhrRxre+2sPVuzJUO3o3r6mZ0D+fcgJtqcv7oxdaTlYvf8Ebvl0FaZf1xs3fPyvmtXvmByDjyb0RbiJveuJOFNNRB5TnAc818gz3/vRI4ApstKHyUzw+eefr4JTCWbF999/j7i4OJx99tkqCO7evbv98c888wx++uknzJkzB507d67ybt17771OBc7++9//4vbbb8c777yj7pNZ6D59+thvC/37ZGdn44033sDbb7+N8ePHq/tat26NM888E96EQbUHxNvWVMtB/5d1h/Hg9xtU25zOjWJUQJ1Uj5VKifRAcmj7BLVJirPo1CgGgSo02KgC6QvfXoo9abk4/40lqlp6y7hIVVWdtReINGk5WlCdYGthSUREzmRG+pZbblGBrKRUf/HFF7jqqqtUQC0z1U8++SRmzZqFo0ePwmw2Iz8/H4cOHarW9/rzzz8xdepUbNu2DVlZWer1CgoKkJeXp9K9ZaZaZs/LsnXrVhQWFtqDf2/FoNqDM9VSxfier9ep68M7Jap0V0l/JaLSAjmYdiQzb1IR/PLpy9Ua6qSYMHx2Uz/OyBE50DPB+HdBRHUuJEKbMfbU93aRpFdLRxEJnGXN9JIlS/Daa6+prz3wwAOYP38+Xn75ZbWOOTw8HJdffjmKi08Vj3XVvn37cMEFF+COO+5Q66BjY2NVevdNN92EoqIiFVTL65enoq95E0ZwHnD6Qf7WIa3w8HkdWFiIiFwi6e9Sd+H71Ydw97lt0aQB2+0ROWL6NxF5jNRDciEF29PCwsJw6aWXqhnqXbt2oX379ujVq5e9aNiECRNwySWXqNsycy3B8YABA6r8fVavXq0Kjb3yyitqFlx8++23To/p1q2bWr/91FNPlXp+27ZtVWAtX7/55pvhrRhUe0BYiBFtEqJUgSFpeyNts4iIqmJIu3i1EVH5QbWeGUZERGWngMssshQQu+6665wC2R9//FHNZstSPCkQdnqlcFe1adNGzXC/9dZb6vUkYJ8+fbrTY6QQmVQHl6rgstbaZDKpImqSEi7rvB9++GFV2EzuHzRoENLS0tQ+y2y3t2CJWA/54faBWPzQ2QyoiYiI3GzaNT1wS4cStE3w/tkiIiJPOeecc1Q69vbt23HNNdc4tcCSYmYDBw5UgbC0t9Jnsauqe/fu6vVeeOEFdOnSRc2My/pqR+3atcO8efOwfv169OvXT82I//LLLwgO1uZ/Jai///77MWXKFHTs2BFjx45Faqpze1FP40y1h9SLCFEbERERuVen5Bjsa2BFdID0siciqg5Jxz5ypPT6b6nQLW2vHMmaaCkyppN0cFfdd999anN0/fXXO90+66yz1Cx2efv5f//3f2rzVtWaqZ42bZoabMnF79+/P1auXFnh47/77jt06NBBPV6m9mfPnl3d/SUiIiIiIiLy3aD6m2++waRJk/DEE09gzZo1akpfUgLKm4Jfvnw5rr76apXzLs3DL774YrVt2rTJHftPREREREREHiDp3FFRUWVu1elp7auqnP4tOfHS0+yGG25Qt2WhuZRinzFjBh555JFSj5dm3eeddx4efPBBe/NwKdEuDbxPX6ROREREREREvuHCCy9UmctlCQkJnCU4VQqqpZeYlEWXCm2OOe7Dhg3DihUrynyO3C8z245kZvvnn3+u7j4TERERERGRh0VHR6st0FUpqE5PT0dJSQkSExOd7pfb27ZtK/M5x44dK/Pxcn95CgsL1abTF8VLOfbqNB13pD+/pq/jLzgepXFMnHE8nHE8SgvEMQmk90pEREQ+WP1byqyX1fxbSq1HRES45XtICjqdwvEojWPijOPhjOMR2GOSl5fn6V0gIiIvYbVaPb0L5OGfX5WCamm+bTQakZKS4nS/3E5KSirzOXJ/VR4vJL3cMWVcZqqbNm2KESNGICYmBjWdXZAPfsOHDw+oPP/ycDxK45g443g443iUFohj4thWhIiIApN+zJMTreHh4Z7eHarhifKafIapUlBtMpnQu3dvLFiwQFXwFhaLRd2eOHFimc+R5t3y9Xvvvdd+n3z4kvvLExoaqrbTyRt11wc2d76WP+B4lMYxccbxcMbxCOwxCZT3SURE5ZPJxvr169u7IElGrcFggD+SmE/qaxUUFKiaWv4yQ52Xl6d+fvJzlJ9nnaV/ywzy+PHj0adPH/Tr1w+vv/46cnNz7dXAx40bh8aNG6sUbnHPPfeoZt6vvPIKRo8eja+//hqrVq3C+++/X+2dJiIiIiIi8jQ9+7a89sL+QgLQ/Px8NSPvbycO6tevX2EWda0E1WPHjkVaWhqmTJmiio316NEDc+fOtRcjO3DggNPZi4EDB+LLL7/EY489hkcffRRt27ZVlb+7dOlSox0nIiIiIiLyJAkwk5OTkZCQ4NdFLOW9LV68GEOGDPGrbK2QkJAazVDXqFCZpHqXl+69aNGiUvddccUVaiMiIiIiIvI3Epi5IzjzVvLezGYzwsLC/Cqodhf/SIgnIiIiIiIi8gAG1URERERERETVxKCaiIiIiIiIqC7XVHuqIbc7+oLKInspnS6vxfUAHI+ycEyccTyccTxKC8Qx0Y9H+vGJao7H+trFMXHG8XDG8XDG8SgtUMcky8XjvU8E1dnZ2eqyadOmnt4VIiIip+NTvXr1PL0bfoHHeiIi8tXjvcHqA6fZpdn4kSNHEB0dXeO+aHK2QQ7YBw8eRExMDAIdx6M0jokzjoczjkdpgTgmcuiUA2yjRo2c2khS9fFYX7s4Js44Hs44Hs44HqUF6phYXTze+8RMtbyBJk2auPU15ZchkH4hKsPxKI1j4ozj4YzjUVqgjQlnqN2Lx/q6wTFxxvFwxvFwxvEoLRDHpJ4Lx3ueXiciIiIiIiKqJgbVRERERERERNUUcEF1aGgonnjiCXVJHI+ycEyccTyccTxK45iQt+HvZGkcE2ccD2ccD2ccj9I4JhXziUJlRERERERERN4o4GaqiYiIiIiIiNyFQTURERERERFRNTGoJiIiIiIiIqomBtVERERERERE1RRQQfW0adPQokULhIWFoX///li5ciV8zdSpU9G3b19ER0cjISEBF198MbZv3+70mIKCAtx5551o2LAhoqKicNlllyElJcXpMQcOHMDo0aMRERGhXufBBx+E2Wx2esyiRYvQq1cvVeWvTZs2mDlzpteP6fPPPw+DwYB77703oMfj8OHDuO6669R7Dg8PR9euXbFq1Sr716U+4ZQpU5CcnKy+PmzYMOzcudPpNY4fP45rr70WMTExqF+/Pm666Sbk5OQ4PWbDhg0YPHiwer9NmzbFiy++WGpfvvvuO3To0EE9RvZj9uzZqEslJSV4/PHH0bJlS/VeW7dujWeeeUaNQaCMx+LFizFmzBg0atRI/X38/PPPTl/3pvfvyr4QVcZb/i+uCR7vK8bjPY/1pwv04z2P9R5mDRBff/211WQyWWfMmGHdvHmz9ZZbbrHWr1/fmpKSYvUlI0eOtH788cfWTZs2WdetW2cdNWqUtVmzZtacnBz7Y26//XZr06ZNrQsWLLCuWrXKesYZZ1gHDhxo/7rZbLZ26dLFOmzYMOvatWuts2fPtsbFxVknT55sf8yePXusERER1kmTJlm3bNlifeutt6xGo9E6d+5crx3TlStXWlu0aGHt1q2b9Z577gnY8Th+/Li1efPm1gkTJlj/+ecfte9//PGHddeuXfbHPP/889b/b+9OYKMqwgCOfy0tgqncSCNyxlKwGMQSTMWASU2hIQFp0mpDuDQBEQIhBjEBBI/WpB5RCHIZgYSCVkNBi0YaKKdAOEJBJXhQEA0NYigtaS2Fjvmm2XV3e9Aspfu27/9Llu3bnezODG/n25mdN9O5c2ezfft2U1xcbCZMmGAGDBhgqqqqvGnGjRtnhg0bZo4cOWIOHDhgHnnkEZOZmel9/vr166ZXr15m8uTJ9nzcunWr6dixo1m7dq03zaFDh2w95eTk2HpbsmSJiY6ONmfOnGm1+sjKyjLdu3c3BQUFpqSkxHz55ZcmJibGfPzxx66pDz2nFy9ebLZt26bfLEx+fr7f804qf3PyAjTFKW3x3SLeN454T6xviNvjPbE+tFzTqR45cqSZM2eO9/j27dvmoYceMu+++64JZ1euXLEfnH379tnjsrIye+JqQ+Jx9uxZm+bw4cPeD11kZKQpLS31plm9erXp1KmTqa6utsevvfaaSUhI8Huv559/3gZ5J9ZpRUWFiYuLM4WFhWbMmDHeIOvG+li0aJF5+umnG32+trbWxMbGmvfee8/7mNbTfffdZxtHpY2g1tGxY8e8ab777jsTERFh/vrrL3v8ySefmK5du3rryPPe8fHx3uOMjAwzfvx4v/d/8sknzaxZs0xr0fd/8cUX/R5LS0uzAcGN9REYaJ1U/ubkBbgTp7TFLY14X4d4X4dYXx/x/n/E+tbniunfN2/elBMnTtipBR6RkZH2+PDhwxLOrl+/bu+7detm77WcNTU1fmXV6Rd9+/b1llXvdSpGr169vGnGjh0r5eXl8tNPP3nT+L6GJ43nNZxWpzrdS6dzBebZjfXx9ddfy4gRIyQ9Pd1ObRs+fLisX7/e+3xJSYmUlpb65bVz5852+ppvnei0H30dD02vZTp69Kg3zejRo6V9+/Z+daLTE69du9asemsNTz31lOzevVt++eUXe1xcXCwHDx6U1NRUV9ZHICeVvzl5AZripLa4pRHv6xDv6xDr6yPeN85JZS9po7HeFZ3qq1ev2ussfBtRpcf6nxquamtr7bVEo0aNkqFDh9rHtDx6ouuHorGy6n1DdeF5rqk0GniqqqocVaeff/65nDx50l5/FsiN9XH+/HlZvXq1xMXFyffffy+zZ8+WefPmyaZNm7xl8eStsbzqvQZpX1FRUfbLXEvUW2vWyeuvvy4vvPCC/XIVHR1tv3jo50avGXJjfQRyUvmbkxegKU5qi1sS8b4O8f5/xPr6iPeNc1LZS9torI8KdQZwd6O1P/74ox2Fc6tLly7J/PnzpbCw0C6GgLovXzrKmJ2dbY81qOh5smbNGpk2bZq4TV5enuTm5sqWLVskISFBTp06ZYOsLuThxvoAEH6I98T7QMT6+oj3CCVX/FLdo0cPadeuXb0VIPU4NjZWwtHcuXOloKBAioqK5OGHH/Y+ruXRqUllZWWNllXvG6oLz3NNpdHVAHWVPqfUqU7BunLlil2lU0fT9LZv3z5ZsWKF/VtHvdxUH0pXUnz00Uf9HhsyZIhd8VR58tNUXvVe69WXro6qq0K2RL21Zp3oyq6e0Wud9jdlyhRZsGCB95cOt9VHICeVvzl5AZripLa4pRDv6xDv/RHr6yPeN85JZY9to7HeFZ1qnQ6UmJhor7PwHeHT46SkJAknuvaABtj8/HzZs2eP3TbAl5ZTp7z4llWvc9BG1lNWvT9z5ozfB0dHfjVgeBpoTeP7Gp40ntdwSp0mJyfbsuhopOemI7c61cfzt5vqQ+n0wMBtV/T6on79+tm/9ZzRRss3rzqtTa+X8a0T/WKiX2I89HzTMuk1L540un2DXsPmWyfx8fHStWvXZtVba6isrLTXA/nSL0RaFjfWRyAnlb85eQGa4qS2+G4R7/0R7/0R6+sj3jfOSWUf0FZjvXEJ3f5AV5XbuHGjXd1u5syZdvsD3xUgw8Hs2bPtEvR79+41ly9f9t4qKyv9tpTQbTf27Nljt5RISkqyt8AtJVJSUuw2HbpNRM+ePRvcUmLhwoV29cxVq1Y1uKWEE+vUdzVQN9aHbjUSFRVlt5b49ddfTW5urs375s2b/bYy0Lzt2LHDnD592kycOLHBbRWGDx9ut+o4ePCgXW3Vd1sFXalRt1WYMmWK3VZBy6/vE7itgubl/ffft/W2bNmyVt9mY9q0aaZ3797eLTZ0qwndQkVXeHVLfehqubp9jN602f/www/t3xcvXnRc+ZuTF6ApTmmL7xbx/s7cHO+J9fW5Pd4T60PLNZ1qpXsNamOrewvqdgi6B1u40Q9JQzfdy9JDT8hXXnnFLnmvJ/qkSZNsIPZ14cIFk5qaaveW0wbn1VdfNTU1NX5pioqKzOOPP27ra+DAgX7v4eQ6DQyybqyPb775xn5x0KA/ePBgs27dOr/ndTuDpUuX2oZR0yQnJ5tz5875pfnnn39sQ6p7POp2IzNmzLANti/dW1C39NDX0ECmjWSgvLw8M2jQIFsnuk3Jzp07TWsqLy+354P+v3To0MH+3+k+jr7bQbT1+tBzt6F2Q7+AOK38zckLcCdOaYvvBvH+ztwe74n1/twe74n1oRWh/4T613IAAAAAAMKRK66pBgAAAADgXqBTDQAAAABAkOhUAwAAAAAQJDrVAAAAAAAEiU41AAAAAABBolMNAAAAAECQ6FQDAAAAABAkOtUAAAAAAASJTjXQBk2fPl2ee+65UGcDAADcI8R6wDnoVAMAAAAAECQ61UAY++qrr+Sxxx6Tjh07Svfu3eXZZ5+VhQsXyqZNm2THjh0SERFhb3v37rXpL126JBkZGdKlSxfp1q2bTJw4US5cuFBv1PvNN9+Unj17SqdOneTll1+WmzdvhrCUAAC4F7EecL6oUGcAQHAuX74smZmZkpOTI5MmTZKKigo5cOCATJ06Vf744w8pLy+XDRs22LQaVGtqamTs2LGSlJRk00VFRck777wj48aNk9OnT0v79u1t2t27d0uHDh1scNYgPGPGDBvEs7KyQlxiAADchVgPhAc61UAYB9pbt25JWlqa9OvXzz6mI9lKR7Orq6slNjbWm37z5s1SW1srn376qR3RVhqIdSRbg2pKSop9TAPuZ599Jvfff78kJCTIW2+9ZUfE3377bYmMZHILAACthVgPhAc+NUCYGjZsmCQnJ9vgmp6eLuvXr5dr1641mr64uFh+++03eeCBByQmJsbedFT733//ld9//93vdTXIeuho940bN+x0MgAA0HqI9UB44JdqIEy1a9dOCgsL5YcffpBdu3bJypUrZfHixXL06NEG02uwTExMlNzc3HrP6TVVAADAWYj1QHigUw2EMZ3aNWrUKHt744037NSw/Px8O63r9u3bfmmfeOIJ+eKLL+TBBx+0i5I0NcpdVVVlp5WpI0eO2JHuPn363PPyAAAAf8R6wPmY/g2EKR2lzs7OluPHj9vFSrZt2yZ///23DBkyRPr3728XJDl37pxcvXrVLlwyefJk6dGjh10FVBcvKSkpsddXzZs3T/7880/v6+rqny+99JL8/PPP8u2338qyZctk7ty5XGMFAEArI9YD4YFfqoEwpSPQ+/fvl48++siu/qkj1x988IGkpqbKiBEjbBDVe50KVlRUJM8884xNv2jRIrvgia4g2rt3b3utlu9oth7HxcXJ6NGj7QIouuro8uXLQ1pWAADciFgPhIcIY4wJdSYAOIPuXVlWVibbt28PdVYAAMA9QKwHWh5zPAAAAAAACBKdagAAAAAAgsT0bwAAAAAAgsQv1QAAAAAABIlONQAAAAAAQaJTDQAAAABAkOhUAwAAAAAQJDrVAAAAAAAEiU41AAAAAABBolMNAAAAAECQ6FQDAAAAABAkOtUAAAAAAEhw/gOJcySEUgitUQAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "## selu激活函数，可以加速收敛，效果相对于relu更好"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T12:35:43.483534Z",
     "start_time": "2025-01-17T12:35:41.734329Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3470\n",
      "accuracy: 0.8861\n"
     ]
    }
   ],
   "execution_count": 14
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
